gdbstub.c

   1 /*
   2  * gdb server stub
   3  *
   4  * Copyright (c) 2003-2005 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, see <http://www.gnu.org/licenses/>.
  18  */
  19 #include "config.h"
  20 #include "qemu-common.h"
  21 #ifdef CONFIG_USER_ONLY
  22 #include <stdlib.h>
  23 #include <stdio.h>
  24 #include <stdarg.h>
  25 #include <string.h>
  26 #include <errno.h>
  27 #include <unistd.h>
  28 #include <fcntl.h>
  29
  30 #include "qemu.h"
  31 #else
  32 #include "monitor/monitor.h"
  33 #include "sysemu/char.h"
  34 #include "sysemu/sysemu.h"
  35 #include "exec/gdbstub.h"
  36 #endif
  37
  38 #define MAX_PACKET_LENGTH 4096
  39
  40 #include "cpu.h"
  41 #include "qemu/sockets.h"
  42 #include "sysemu/kvm.h"
  43
  44 static inline int target_memory_rw_debug(CPUState *cpu, target_ulong addr,
  45                                          uint8_t *buf, int len, bool is_write)
  46 {
  47     CPUClass *cc = CPU_GET_CLASS(cpu);
  48
  49     if (cc->memory_rw_debug) {
  50         return cc->memory_rw_debug(cpu, addr, buf, len, is_write);
  51     }
  52     return cpu_memory_rw_debug(cpu, addr, buf, len, is_write);
  53 }
  54
  55 enum {
  56     GDB_SIGNAL_0 = 0,
  57     GDB_SIGNAL_INT = 2,
  58     GDB_SIGNAL_QUIT = 3,
  59     GDB_SIGNAL_TRAP = 5,
  60     GDB_SIGNAL_ABRT = 6,
  61     GDB_SIGNAL_ALRM = 14,
  62     GDB_SIGNAL_IO = 23,
  63     GDB_SIGNAL_XCPU = 24,
  64     GDB_SIGNAL_UNKNOWN = 143
  65 };
  66
  67 #ifdef CONFIG_USER_ONLY
  68
  69 /* Map target signal numbers to GDB protocol signal numbers and vice
  70  * versa.  For user emulation's currently supported systems, we can
  71  * assume most signals are defined.
  72  */
  73
  74 static int gdb_signal_table[] = {
  75     0,
  76     TARGET_SIGHUP,
  77     TARGET_SIGINT,
  78     TARGET_SIGQUIT,
  79     TARGET_SIGILL,
  80     TARGET_SIGTRAP,
  81     TARGET_SIGABRT,
  82     -1, /* SIGEMT */
  83     TARGET_SIGFPE,
  84     TARGET_SIGKILL,
  85     TARGET_SIGBUS,
  86     TARGET_SIGSEGV,
  87     TARGET_SIGSYS,
  88     TARGET_SIGPIPE,
  89     TARGET_SIGALRM,
  90     TARGET_SIGTERM,
  91     TARGET_SIGURG,
  92     TARGET_SIGSTOP,
  93     TARGET_SIGTSTP,
  94     TARGET_SIGCONT,
  95     TARGET_SIGCHLD,
  96     TARGET_SIGTTIN,
  97     TARGET_SIGTTOU,
  98     TARGET_SIGIO,
  99     TARGET_SIGXCPU,
 100     TARGET_SIGXFSZ,
 101     TARGET_SIGVTALRM,
 102     TARGET_SIGPROF,
 103     TARGET_SIGWINCH,
 104     -1, /* SIGLOST */
 105     TARGET_SIGUSR1,
 106     TARGET_SIGUSR2,
 107 #ifdef TARGET_SIGPWR
 108     TARGET_SIGPWR,
 109 #else
 110     -1,
 111 #endif
 112     -1, /* SIGPOLL */
 113     -1,
 114     -1,
 115     -1,
 116     -1,
 117     -1,
 118     -1,
 119     -1,
 120     -1,
 121     -1,
 122     -1,
 123     -1,
 124 #ifdef __SIGRTMIN
 125     __SIGRTMIN + 1,
 126     __SIGRTMIN + 2,
 127     __SIGRTMIN + 3,
 128     __SIGRTMIN + 4,
 129     __SIGRTMIN + 5,
 130     __SIGRTMIN + 6,
 131     __SIGRTMIN + 7,
 132     __SIGRTMIN + 8,
 133     __SIGRTMIN + 9,
 134     __SIGRTMIN + 10,
 135     __SIGRTMIN + 11,
 136     __SIGRTMIN + 12,
 137     __SIGRTMIN + 13,
 138     __SIGRTMIN + 14,
 139     __SIGRTMIN + 15,
 140     __SIGRTMIN + 16,
 141     __SIGRTMIN + 17,
 142     __SIGRTMIN + 18,
 143     __SIGRTMIN + 19,
 144     __SIGRTMIN + 20,
 145     __SIGRTMIN + 21,
 146     __SIGRTMIN + 22,
 147     __SIGRTMIN + 23,
 148     __SIGRTMIN + 24,
 149     __SIGRTMIN + 25,
 150     __SIGRTMIN + 26,
 151     __SIGRTMIN + 27,
 152     __SIGRTMIN + 28,
 153     __SIGRTMIN + 29,
 154     __SIGRTMIN + 30,
 155     __SIGRTMIN + 31,
 156     -1, /* SIGCANCEL */
 157     __SIGRTMIN,
 158     __SIGRTMIN + 32,
 159     __SIGRTMIN + 33,
 160     __SIGRTMIN + 34,
 161     __SIGRTMIN + 35,
 162     __SIGRTMIN + 36,
 163     __SIGRTMIN + 37,
 164     __SIGRTMIN + 38,
 165     __SIGRTMIN + 39,
 166     __SIGRTMIN + 40,
 167     __SIGRTMIN + 41,
 168     __SIGRTMIN + 42,
 169     __SIGRTMIN + 43,
 170     __SIGRTMIN + 44,
 171     __SIGRTMIN + 45,
 172     __SIGRTMIN + 46,
 173     __SIGRTMIN + 47,
 174     __SIGRTMIN + 48,
 175     __SIGRTMIN + 49,
 176     __SIGRTMIN + 50,
 177     __SIGRTMIN + 51,
 178     __SIGRTMIN + 52,
 179     __SIGRTMIN + 53,
 180     __SIGRTMIN + 54,
 181     __SIGRTMIN + 55,
 182     __SIGRTMIN + 56,
 183     __SIGRTMIN + 57,
 184     __SIGRTMIN + 58,
 185     __SIGRTMIN + 59,
 186     __SIGRTMIN + 60,
 187     __SIGRTMIN + 61,
 188     __SIGRTMIN + 62,
 189     __SIGRTMIN + 63,
 190     __SIGRTMIN + 64,
 191     __SIGRTMIN + 65,
 192     __SIGRTMIN + 66,
 193     __SIGRTMIN + 67,
 194     __SIGRTMIN + 68,
 195     __SIGRTMIN + 69,
 196     __SIGRTMIN + 70,
 197     __SIGRTMIN + 71,
 198     __SIGRTMIN + 72,
 199     __SIGRTMIN + 73,
 200     __SIGRTMIN + 74,
 201     __SIGRTMIN + 75,
 202     __SIGRTMIN + 76,
 203     __SIGRTMIN + 77,
 204     __SIGRTMIN + 78,
 205     __SIGRTMIN + 79,
 206     __SIGRTMIN + 80,
 207     __SIGRTMIN + 81,
 208     __SIGRTMIN + 82,
 209     __SIGRTMIN + 83,
 210     __SIGRTMIN + 84,
 211     __SIGRTMIN + 85,
 212     __SIGRTMIN + 86,
 213     __SIGRTMIN + 87,
 214     __SIGRTMIN + 88,
 215     __SIGRTMIN + 89,
 216     __SIGRTMIN + 90,
 217     __SIGRTMIN + 91,
 218     __SIGRTMIN + 92,
 219     __SIGRTMIN + 93,
 220     __SIGRTMIN + 94,
 221     __SIGRTMIN + 95,
 222     -1, /* SIGINFO */
 223     -1, /* UNKNOWN */
 224     -1, /* DEFAULT */
 225     -1,
 226     -1,
 227     -1,
 228     -1,
 229     -1,
 230     -1
 231 #endif
 232 };
 233 #else
 234 /* In system mode we only need SIGINT and SIGTRAP; other signals
 235    are not yet supported.  */
 236
 237 enum {
 238     TARGET_SIGINT = 2,
 239     TARGET_SIGTRAP = 5
 240 };
 241
 242 static int gdb_signal_table[] = {
 243     -1,
 244     -1,
 245     TARGET_SIGINT,
 246     -1,
 247     -1,
 248     TARGET_SIGTRAP
 249 };
 250 #endif
 251
 252 #ifdef CONFIG_USER_ONLY
 253 static int target_signal_to_gdb (int sig)
 254 {
 255     int i;
 256     for (i = 0; i < ARRAY_SIZE (gdb_signal_table); i++)
 257         if (gdb_signal_table[i] == sig)
 258             return i;
 259     return GDB_SIGNAL_UNKNOWN;
 260 }
 261 #endif
 262
 263 static int gdb_signal_to_target (int sig)
 264 {
 265     if (sig < ARRAY_SIZE (gdb_signal_table))
 266         return gdb_signal_table[sig];
 267     else
 268         return -1;
 269 }
 270
 271 //#define DEBUG_GDB
 272
 273 typedef struct GDBRegisterState {
 274     int base_reg;
 275     int num_regs;
 276     gdb_reg_cb get_reg;
 277     gdb_reg_cb set_reg;
 278     const char *xml;
 279     struct GDBRegisterState *next;
 280 } GDBRegisterState;
 281
 282 enum RSState {
 283     RS_INACTIVE,
 284     RS_IDLE,
 285     RS_GETLINE,
 286     RS_CHKSUM1,
 287     RS_CHKSUM2,
 288 };
 289 typedef struct GDBState {
 290     CPUState *c_cpu; /* current CPU for step/continue ops */
 291     CPUState *g_cpu; /* current CPU for other ops */
 292     CPUState *query_cpu; /* for q{f|s}ThreadInfo */
 293     enum RSState state; /* parsing state */
 294     char line_buf[MAX_PACKET_LENGTH];
 295     int line_buf_index;
 296     int line_csum;
 297     uint8_t last_packet[MAX_PACKET_LENGTH + 4];
 298     int last_packet_len;
 299     int signal;
 300 #ifdef CONFIG_USER_ONLY
 301     int fd;
 302     int running_state;
 303 #else
 304     CharDriverState *chr;
 305     CharDriverState *mon_chr;
 306 #endif
 307     char syscall_buf[256];
 308     gdb_syscall_complete_cb current_syscall_cb;
 309 } GDBState;
 310
 311 /* By default use no IRQs and no timers while single stepping so as to
 312  * make single stepping like an ICE HW step.
 313  */
 314 static int sstep_flags = SSTEP_ENABLE|SSTEP_NOIRQ|SSTEP_NOTIMER;
 315
 316 static GDBState *gdbserver_state;
 317
 318 bool gdb_has_xml;
 319
 320 #ifdef CONFIG_USER_ONLY
 321 /* XXX: This is not thread safe.  Do we care?  */
 322 static int gdbserver_fd = -1;
 323
 324 static int get_char(GDBState *s)
 325 {
 326     uint8_t ch;
 327     int ret;
 328
 329     for(;;) {
 330         ret = qemu_recv(s->fd, &ch, 1, 0);
 331         if (ret < 0) {
 332             if (errno == ECONNRESET)
 333                 s->fd = -1;
 334             if (errno != EINTR && errno != EAGAIN)
 335                 return -1;
 336         } else if (ret == 0) {
 337             close(s->fd);
 338             s->fd = -1;
 339             return -1;
 340         } else {
 341             break;
 342         }
 343     }
 344     return ch;
 345 }
 346 #endif
 347
 348 static enum {
 349     GDB_SYS_UNKNOWN,
 350     GDB_SYS_ENABLED,
 351     GDB_SYS_DISABLED,
 352 } gdb_syscall_mode;
 353
 354 /* If gdb is connected when the first semihosting syscall occurs then use
 355    remote gdb syscalls.  Otherwise use native file IO.  */
 356 int use_gdb_syscalls(void)
 357 {
 358     if (gdb_syscall_mode == GDB_SYS_UNKNOWN) {
 359         gdb_syscall_mode = (gdbserver_state ? GDB_SYS_ENABLED
 360                                             : GDB_SYS_DISABLED);
 361     }
 362     return gdb_syscall_mode == GDB_SYS_ENABLED;
 363 }
 364
 365 /* Resume execution.  */
 366 static inline void gdb_continue(GDBState *s)
 367 {
 368 #ifdef CONFIG_USER_ONLY
 369     s->running_state = 1;
 370 #else
 371     if (!runstate_needs_reset()) {
 372         vm_start();
 373     }
 374 #endif
 375 }
 376
 377 static void put_buffer(GDBState *s, const uint8_t *buf, int len)
 378 {
 379 #ifdef CONFIG_USER_ONLY
 380     int ret;
 381
 382     while (len > 0) {
 383         ret = send(s->fd, buf, len, 0);
 384         if (ret < 0) {
 385             if (errno != EINTR && errno != EAGAIN)
 386                 return;
 387         } else {
 388             buf += ret;
 389             len -= ret;
 390         }
 391     }
 392 #else
 393     qemu_chr_fe_write(s->chr, buf, len);
 394 #endif
 395 }
 396
 397 static inline int fromhex(int v)
 398 {
 399     if (v >= '0' && v <= '9')
 400         return v - '0';
 401     else if (v >= 'A' && v <= 'F')
 402         return v - 'A' + 10;
 403     else if (v >= 'a' && v <= 'f')
 404         return v - 'a' + 10;
 405     else
 406         return 0;
 407 }
 408
 409 static inline int tohex(int v)
 410 {
 411     if (v < 10)
 412         return v + '0';
 413     else
 414         return v - 10 + 'a';
 415 }
 416
 417 static void memtohex(char *buf, const uint8_t *mem, int len)
 418 {
 419     int i, c;
 420     char *q;
 421     q = buf;
 422     for(i = 0; i < len; i++) {
 423         c = mem[i];
 424         *q++ = tohex(c >> 4);
 425         *q++ = tohex(c & 0xf);
 426     }
 427     *q = '\0';
 428 }
 429
 430 static void hextomem(uint8_t *mem, const char *buf, int len)
 431 {
 432     int i;
 433
 434     for(i = 0; i < len; i++) {
 435         mem[i] = (fromhex(buf[0]) << 4) | fromhex(buf[1]);
 436         buf += 2;
 437     }
 438 }
 439
 440 /* return -1 if error, 0 if OK */
 441 static int put_packet_binary(GDBState *s, const char *buf, int len)
 442 {
 443     int csum, i;
 444     uint8_t *p;
 445
 446     for(;;) {
 447         p = s->last_packet;
 448         *(p++) = '$';
 449         memcpy(p, buf, len);
 450         p += len;
 451         csum = 0;
 452         for(i = 0; i < len; i++) {
 453             csum += buf[i];
 454         }
 455         *(p++) = '#';
 456         *(p++) = tohex((csum >> 4) & 0xf);
 457         *(p++) = tohex((csum) & 0xf);
 458
 459         s->last_packet_len = p - s->last_packet;
 460         put_buffer(s, (uint8_t *)s->last_packet, s->last_packet_len);
 461
 462 #ifdef CONFIG_USER_ONLY
 463         i = get_char(s);
 464         if (i < 0)
 465             return -1;
 466         if (i == '+')
 467             break;
 468 #else
 469         break;
 470 #endif
 471     }
 472     return 0;
 473 }
 474
 475 /* return -1 if error, 0 if OK */
 476 static int put_packet(GDBState *s, const char *buf)
 477 {
 478 #ifdef DEBUG_GDB
 479     printf("reply='%s'\n", buf);
 480 #endif
 481
 482     return put_packet_binary(s, buf, strlen(buf));
 483 }
 484
 485 /* Encode data using the encoding for 'x' packets.  */
 486 static int memtox(char *buf, const char *mem, int len)
 487 {
 488     char *p = buf;
 489     char c;
 490
 491     while (len--) {
 492         c = *(mem++);
 493         switch (c) {
 494         case '#': case '$': case '*': case '}':
 495             *(p++) = '}';
 496             *(p++) = c ^ 0x20;
 497             break;
 498         default:
 499             *(p++) = c;
 500             break;
 501         }
 502     }
 503     return p - buf;
 504 }
 505
 506 static const char *get_feature_xml(const char *p, const char **newp,
 507                                    CPUClass *cc)
 508 {
 509     size_t len;
 510     int i;
 511     const char *name;
 512     static char target_xml[1024];
 513
 514     len = 0;
 515     while (p[len] && p[len] != ':')
 516         len++;
 517     *newp = p + len;
 518
 519     name = NULL;
 520     if (strncmp(p, "target.xml", len) == 0) {
 521         /* Generate the XML description for this CPU.  */
 522         if (!target_xml[0]) {
 523             GDBRegisterState *r;
 524             CPUState *cpu = first_cpu;
 525
 526             snprintf(target_xml, sizeof(target_xml),
 527                      "<?xml version=\"1.0\"?>"
 528                      "<!DOCTYPE target SYSTEM \"gdb-target.dtd\">"
 529                      "<target>"
 530                      "<xi:include href=\"%s\"/>",
 531                      cc->gdb_core_xml_file);
 532
 533             for (r = cpu->gdb_regs; r; r = r->next) {
 534                 pstrcat(target_xml, sizeof(target_xml), "<xi:include href=\"");
 535                 pstrcat(target_xml, sizeof(target_xml), r->xml);
 536                 pstrcat(target_xml, sizeof(target_xml), "\"/>");
 537             }
 538             pstrcat(target_xml, sizeof(target_xml), "</target>");
 539         }
 540         return target_xml;
 541     }
 542     for (i = 0; ; i++) {
 543         name = xml_builtin[i][0];
 544         if (!name || (strncmp(name, p, len) == 0 && strlen(name) == len))
 545             break;
 546     }
 547     return name ? xml_builtin[i][1] : NULL;
 548 }
 549
 550 static int gdb_read_register(CPUState *cpu, uint8_t *mem_buf, int reg)
 551 {
 552     CPUClass *cc = CPU_GET_CLASS(cpu);
 553     CPUArchState *env = cpu->env_ptr;
 554     GDBRegisterState *r;
 555
 556     if (reg < cc->gdb_num_core_regs) {
 557         return cc->gdb_read_register(cpu, mem_buf, reg);
 558     }
 559
 560     for (r = cpu->gdb_regs; r; r = r->next) {
 561         if (r->base_reg <= reg && reg < r->base_reg + r->num_regs) {
 562             return r->get_reg(env, mem_buf, reg - r->base_reg);
 563         }
 564     }
 565     return 0;
 566 }
 567
 568 static int gdb_write_register(CPUState *cpu, uint8_t *mem_buf, int reg)
 569 {
 570     CPUClass *cc = CPU_GET_CLASS(cpu);
 571     CPUArchState *env = cpu->env_ptr;
 572     GDBRegisterState *r;
 573
 574     if (reg < cc->gdb_num_core_regs) {
 575         return cc->gdb_write_register(cpu, mem_buf, reg);
 576     }
 577
 578     for (r = cpu->gdb_regs; r; r = r->next) {
 579         if (r->base_reg <= reg && reg < r->base_reg + r->num_regs) {
 580             return r->set_reg(env, mem_buf, reg - r->base_reg);
 581         }
 582     }
 583     return 0;
 584 }
 585
 586 /* Register a supplemental set of CPU registers.  If g_pos is nonzero it
 587    specifies the first register number and these registers are included in
 588    a standard "g" packet.  Direction is relative to gdb, i.e. get_reg is
 589    gdb reading a CPU register, and set_reg is gdb modifying a CPU register.
 590  */
 591
 592 void gdb_register_coprocessor(CPUState *cpu,
 593                               gdb_reg_cb get_reg, gdb_reg_cb set_reg,
 594                               int num_regs, const char *xml, int g_pos)
 595 {
 596     GDBRegisterState *s;
 597     GDBRegisterState **p;
 598
 599     p = &cpu->gdb_regs;
 600     while (*p) {
 601         /* Check for duplicates.  */
 602         if (strcmp((*p)->xml, xml) == 0)
 603             return;
 604         p = &(*p)->next;
 605     }
 606
 607     s = g_new0(GDBRegisterState, 1);
 608     s->base_reg = cpu->gdb_num_regs;
 609     s->num_regs = num_regs;
 610     s->get_reg = get_reg;
 611     s->set_reg = set_reg;
 612     s->xml = xml;
 613
 614     /* Add to end of list.  */
 615     cpu->gdb_num_regs += num_regs;
 616     *p = s;
 617     if (g_pos) {
 618         if (g_pos != s->base_reg) {
 619             fprintf(stderr, "Error: Bad gdb register numbering for '%s'\n"
 620                     "Expected %d got %d\n", xml, g_pos, s->base_reg);
 621         } else {
 622             cpu->gdb_num_g_regs = cpu->gdb_num_regs;
 623         }
 624     }
 625 }
 626
 627 #ifndef CONFIG_USER_ONLY
 628 /* Translate GDB watchpoint type to a flags value for cpu_watchpoint_* */
 629 static inline int xlat_gdb_type(CPUState *cpu, int gdbtype)
 630 {
 631     static const int xlat[] = {
 632         [GDB_WATCHPOINT_WRITE]  = BP_GDB | BP_MEM_WRITE,
 633         [GDB_WATCHPOINT_READ]   = BP_GDB | BP_MEM_READ,
 634         [GDB_WATCHPOINT_ACCESS] = BP_GDB | BP_MEM_ACCESS,
 635     };
 636
 637     CPUClass *cc = CPU_GET_CLASS(cpu);
 638     int cputype = xlat[gdbtype];
 639
 640     if (cc->gdb_stop_before_watchpoint) {
 641         cputype |= BP_STOP_BEFORE_ACCESS;
 642     }
 643     return cputype;
 644 }
 645 #endif
 646
 647 static int gdb_breakpoint_insert(target_ulong addr, target_ulong len, int type)
 648 {
 649     CPUState *cpu;
 650     int err = 0;
 651
 652     if (kvm_enabled()) {
 653         return kvm_insert_breakpoint(gdbserver_state->c_cpu, addr, len, type);
 654     }
 655
 656     switch (type) {
 657     case GDB_BREAKPOINT_SW:
 658     case GDB_BREAKPOINT_HW:
 659         CPU_FOREACH(cpu) {
 660             err = cpu_breakpoint_insert(cpu, addr, BP_GDB, NULL);
 661             if (err) {
 662                 break;
 663             }
 664         }
 665         return err;
 666 #ifndef CONFIG_USER_ONLY
 667     case GDB_WATCHPOINT_WRITE:
 668     case GDB_WATCHPOINT_READ:
 669     case GDB_WATCHPOINT_ACCESS:
 670         CPU_FOREACH(cpu) {
 671             err = cpu_watchpoint_insert(cpu, addr, len,
 672                                         xlat_gdb_type(cpu, type), NULL);
 673             if (err) {
 674                 break;
 675             }
 676         }
 677         return err;
 678 #endif
 679     default:
 680         return -ENOSYS;
 681     }
 682 }
 683
 684 static int gdb_breakpoint_remove(target_ulong addr, target_ulong len, int type)
 685 {
 686     CPUState *cpu;
 687     int err = 0;
 688
 689     if (kvm_enabled()) {
 690         return kvm_remove_breakpoint(gdbserver_state->c_cpu, addr, len, type);
 691     }
 692
 693     switch (type) {
 694     case GDB_BREAKPOINT_SW:
 695     case GDB_BREAKPOINT_HW:
 696         CPU_FOREACH(cpu) {
 697             err = cpu_breakpoint_remove(cpu, addr, BP_GDB);
 698             if (err) {
 699                 break;
 700             }
 701         }
 702         return err;
 703 #ifndef CONFIG_USER_ONLY
 704     case GDB_WATCHPOINT_WRITE:
 705     case GDB_WATCHPOINT_READ:
 706     case GDB_WATCHPOINT_ACCESS:
 707         CPU_FOREACH(cpu) {
 708             err = cpu_watchpoint_remove(cpu, addr, len,
 709                                         xlat_gdb_type(cpu, type));
 710             if (err)
 711                 break;
 712         }
 713         return err;
 714 #endif
 715     default:
 716         return -ENOSYS;
 717     }
 718 }
 719
 720 static void gdb_breakpoint_remove_all(void)
 721 {
 722     CPUState *cpu;
 723
 724     if (kvm_enabled()) {
 725         kvm_remove_all_breakpoints(gdbserver_state->c_cpu);
 726         return;
 727     }
 728
 729     CPU_FOREACH(cpu) {
 730         cpu_breakpoint_remove_all(cpu, BP_GDB);
 731 #ifndef CONFIG_USER_ONLY
 732         cpu_watchpoint_remove_all(cpu, BP_GDB);
 733 #endif
 734     }
 735 }
 736
 737 static void gdb_set_cpu_pc(GDBState *s, target_ulong pc)
 738 {
 739     CPUState *cpu = s->c_cpu;
 740     CPUClass *cc = CPU_GET_CLASS(cpu);
 741
 742     cpu_synchronize_state(cpu);
 743     if (cc->set_pc) {
 744         cc->set_pc(cpu, pc);
 745     }
 746 }
 747
 748 static CPUState *find_cpu(uint32_t thread_id)
 749 {
 750     CPUState *cpu;
 751
 752     CPU_FOREACH(cpu) {
 753         if (cpu_index(cpu) == thread_id) {
 754             return cpu;
 755         }
 756     }
 757
 758     return NULL;
 759 }
 760
 761 static int gdb_handle_packet(GDBState *s, const char *line_buf)
 762 {
 763     CPUState *cpu;
 764     CPUClass *cc;
 765     const char *p;
 766     uint32_t thread;
 767     int ch, reg_size, type, res;
 768     char buf[MAX_PACKET_LENGTH];
 769     uint8_t mem_buf[MAX_PACKET_LENGTH];
 770     uint8_t *registers;
 771     target_ulong addr, len;
 772
 773 #ifdef DEBUG_GDB
 774     printf("command='%s'\n", line_buf);
 775 #endif
 776     p = line_buf;
 777     ch = *p++;
 778     switch(ch) {
 779     case '?':
 780         /* TODO: Make this return the correct value for user-mode.  */
 781         snprintf(buf, sizeof(buf), "T%02xthread:%02x;", GDB_SIGNAL_TRAP,
 782                  cpu_index(s->c_cpu));
 783         put_packet(s, buf);
 784         /* Remove all the breakpoints when this query is issued,
 785          * because gdb is doing and initial connect and the state
 786          * should be cleaned up.
 787          */
 788         gdb_breakpoint_remove_all();
 789         break;
 790     case 'c':
 791         if (*p != '\0') {
 792             addr = strtoull(p, (char **)&p, 16);
 793             gdb_set_cpu_pc(s, addr);
 794         }
 795         s->signal = 0;
 796         gdb_continue(s);
 797         return RS_IDLE;
 798     case 'C':
 799         s->signal = gdb_signal_to_target (strtoul(p, (char **)&p, 16));
 800         if (s->signal == -1)
 801             s->signal = 0;
 802         gdb_continue(s);
 803         return RS_IDLE;
 804     case 'v':
 805         if (strncmp(p, "Cont", 4) == 0) {
 806             int res_signal, res_thread;
 807
 808             p += 4;
 809             if (*p == '?') {
 810                 put_packet(s, "vCont;c;C;s;S");
 811                 break;
 812             }
 813             res = 0;
 814             res_signal = 0;
 815             res_thread = 0;
 816             while (*p) {
 817                 int action, signal;
 818
 819                 if (*p++ != ';') {
 820                     res = 0;
 821                     break;
 822                 }
 823                 action = *p++;
 824                 signal = 0;
 825                 if (action == 'C' || action == 'S') {
 826                     signal = gdb_signal_to_target(strtoul(p, (char **)&p, 16));
 827                     if (signal == -1) {
 828                         signal = 0;
 829                     }
 830                 } else if (action != 'c' && action != 's') {
 831                     res = 0;
 832                     break;
 833                 }
 834                 thread = 0;
 835                 if (*p == ':') {
 836                     thread = strtoull(p+1, (char **)&p, 16);
 837                 }
 838                 action = tolower(action);
 839                 if (res == 0 || (res == 'c' && action == 's')) {
 840                     res = action;
 841                     res_signal = signal;
 842                     res_thread = thread;
 843                 }
 844             }
 845             if (res) {
 846                 if (res_thread != -1 && res_thread != 0) {
 847                     cpu = find_cpu(res_thread);
 848                     if (cpu == NULL) {
 849                         put_packet(s, "E22");
 850                         break;
 851                     }
 852                     s->c_cpu = cpu;
 853                 }
 854                 if (res == 's') {
 855                     cpu_single_step(s->c_cpu, sstep_flags);
 856                 }
 857                 s->signal = res_signal;
 858                 gdb_continue(s);
 859                 return RS_IDLE;
 860             }
 861             break;
 862         } else {
 863             goto unknown_command;
 864         }
 865     case 'k':
 866 #ifdef CONFIG_USER_ONLY
 867         /* Kill the target */
 868         fprintf(stderr, "\nQEMU: Terminated via GDBstub\n");
 869         exit(0);
 870 #endif
 871     case 'D':
 872         /* Detach packet */
 873         gdb_breakpoint_remove_all();
 874         gdb_syscall_mode = GDB_SYS_DISABLED;
 875         gdb_continue(s);
 876         put_packet(s, "OK");
 877         break;
 878     case 's':
 879         if (*p != '\0') {
 880             addr = strtoull(p, (char **)&p, 16);
 881             gdb_set_cpu_pc(s, addr);
 882         }
 883         cpu_single_step(s->c_cpu, sstep_flags);
 884         gdb_continue(s);
 885         return RS_IDLE;
 886     case 'F':
 887         {
 888             target_ulong ret;
 889             target_ulong err;
 890
 891             ret = strtoull(p, (char **)&p, 16);
 892             if (*p == ',') {
 893                 p++;
 894                 err = strtoull(p, (char **)&p, 16);
 895             } else {
 896                 err = 0;
 897             }
 898             if (*p == ',')
 899                 p++;
 900             type = *p;
 901             if (s->current_syscall_cb) {
 902                 s->current_syscall_cb(s->c_cpu, ret, err);
 903                 s->current_syscall_cb = NULL;
 904             }
 905             if (type == 'C') {
 906                 put_packet(s, "T02");
 907             } else {
 908                 gdb_continue(s);
 909             }
 910         }
 911         break;
 912     case 'g':
 913         cpu_synchronize_state(s->g_cpu);
 914         len = 0;
 915         for (addr = 0; addr < s->g_cpu->gdb_num_g_regs; addr++) {
 916             reg_size = gdb_read_register(s->g_cpu, mem_buf + len, addr);
 917             len += reg_size;
 918         }
 919         memtohex(buf, mem_buf, len);
 920         put_packet(s, buf);
 921         break;
 922     case 'G':
 923         cpu_synchronize_state(s->g_cpu);
 924         registers = mem_buf;
 925         len = strlen(p) / 2;
 926         hextomem((uint8_t *)registers, p, len);
 927         for (addr = 0; addr < s->g_cpu->gdb_num_g_regs && len > 0; addr++) {
 928             reg_size = gdb_write_register(s->g_cpu, registers, addr);
 929             len -= reg_size;
 930             registers += reg_size;
 931         }
 932         put_packet(s, "OK");
 933         break;
 934     case 'm':
 935         addr = strtoull(p, (char **)&p, 16);
 936         if (*p == ',')
 937             p++;
 938         len = strtoull(p, NULL, 16);
 939         if (target_memory_rw_debug(s->g_cpu, addr, mem_buf, len, false) != 0) {
 940             put_packet (s, "E14");
 941         } else {
 942             memtohex(buf, mem_buf, len);
 943             put_packet(s, buf);
 944         }
 945         break;
 946     case 'M':
 947         addr = strtoull(p, (char **)&p, 16);
 948         if (*p == ',')
 949             p++;
 950         len = strtoull(p, (char **)&p, 16);
 951         if (*p == ':')
 952             p++;
 953         hextomem(mem_buf, p, len);
 954         if (target_memory_rw_debug(s->g_cpu, addr, mem_buf, len,
 955                                    true) != 0) {
 956             put_packet(s, "E14");
 957         } else {
 958             put_packet(s, "OK");
 959         }
 960         break;
 961     case 'p':
 962         /* Older gdb are really dumb, and don't use 'g' if 'p' is avaialable.
 963            This works, but can be very slow.  Anything new enough to
 964            understand XML also knows how to use this properly.  */
 965         if (!gdb_has_xml)
 966             goto unknown_command;
 967         addr = strtoull(p, (char **)&p, 16);
 968         reg_size = gdb_read_register(s->g_cpu, mem_buf, addr);
 969         if (reg_size) {
 970             memtohex(buf, mem_buf, reg_size);
 971             put_packet(s, buf);
 972         } else {
 973             put_packet(s, "E14");
 974         }
 975         break;
 976     case 'P':
 977         if (!gdb_has_xml)
 978             goto unknown_command;
 979         addr = strtoull(p, (char **)&p, 16);
 980         if (*p == '=')
 981             p++;
 982         reg_size = strlen(p) / 2;
 983         hextomem(mem_buf, p, reg_size);
 984         gdb_write_register(s->g_cpu, mem_buf, addr);
 985         put_packet(s, "OK");
 986         break;
 987     case 'Z':
 988     case 'z':
 989         type = strtoul(p, (char **)&p, 16);
 990         if (*p == ',')
 991             p++;
 992         addr = strtoull(p, (char **)&p, 16);
 993         if (*p == ',')
 994             p++;
 995         len = strtoull(p, (char **)&p, 16);
 996         if (ch == 'Z')
 997             res = gdb_breakpoint_insert(addr, len, type);
 998         else
 999             res = gdb_breakpoint_remove(addr, len, type);
1000         if (res >= 0)
1001              put_packet(s, "OK");
1002         else if (res == -ENOSYS)
1003             put_packet(s, "");
1004         else
1005             put_packet(s, "E22");
1006         break;
1007     case 'H':
1008         type = *p++;
1009         thread = strtoull(p, (char **)&p, 16);
1010         if (thread == -1 || thread == 0) {
1011             put_packet(s, "OK");
1012             break;
1013         }
1014         cpu = find_cpu(thread);
1015         if (cpu == NULL) {
1016             put_packet(s, "E22");
1017             break;
1018         }
1019         switch (type) {
1020         case 'c':
1021             s->c_cpu = cpu;
1022             put_packet(s, "OK");
1023             break;
1024         case 'g':
1025             s->g_cpu = cpu;
1026             put_packet(s, "OK");
1027             break;
1028         default:
1029              put_packet(s, "E22");
1030              break;
1031         }
1032         break;
1033     case 'T':
1034         thread = strtoull(p, (char **)&p, 16);
1035         cpu = find_cpu(thread);
1036
1037         if (cpu != NULL) {
1038             put_packet(s, "OK");
1039         } else {
1040             put_packet(s, "E22");
1041         }
1042         break;
1043     case 'q':
1044     case 'Q':
1045         /* parse any 'q' packets here */
1046         if (!strcmp(p,"qemu.sstepbits")) {
1047             /* Query Breakpoint bit definitions */
1048             snprintf(buf, sizeof(buf), "ENABLE=%x,NOIRQ=%x,NOTIMER=%x",
1049                      SSTEP_ENABLE,
1050                      SSTEP_NOIRQ,
1051                      SSTEP_NOTIMER);
1052             put_packet(s, buf);
1053             break;
1054         } else if (strncmp(p,"qemu.sstep",10) == 0) {
1055             /* Display or change the sstep_flags */
1056             p += 10;
1057             if (*p != '=') {
1058                 /* Display current setting */
1059                 snprintf(buf, sizeof(buf), "0x%x", sstep_flags);
1060                 put_packet(s, buf);
1061                 break;
1062             }
1063             p++;
1064             type = strtoul(p, (char **)&p, 16);
1065             sstep_flags = type;
1066             put_packet(s, "OK");
1067             break;
1068         } else if (strcmp(p,"C") == 0) {
1069             /* "Current thread" remains vague in the spec, so always return
1070              *  the first CPU (gdb returns the first thread). */
1071             put_packet(s, "QC1");
1072             break;
1073         } else if (strcmp(p,"fThreadInfo") == 0) {
1074             s->query_cpu = first_cpu;
1075             goto report_cpuinfo;
1076         } else if (strcmp(p,"sThreadInfo") == 0) {
1077         report_cpuinfo:
1078             if (s->query_cpu) {
1079                 snprintf(buf, sizeof(buf), "m%x", cpu_index(s->query_cpu));
1080                 put_packet(s, buf);
1081                 s->query_cpu = CPU_NEXT(s->query_cpu);
1082             } else
1083                 put_packet(s, "l");
1084             break;
1085         } else if (strncmp(p,"ThreadExtraInfo,", 16) == 0) {
1086             thread = strtoull(p+16, (char **)&p, 16);
1087             cpu = find_cpu(thread);
1088             if (cpu != NULL) {
1089                 cpu_synchronize_state(cpu);
1090                 len = snprintf((char *)mem_buf, sizeof(mem_buf),
1091                                "CPU#%d [%s]", cpu->cpu_index,
1092                                cpu->halted ? "halted " : "running");
1093                 memtohex(buf, mem_buf, len);
1094                 put_packet(s, buf);
1095             }
1096             break;
1097         }
1098 #ifdef CONFIG_USER_ONLY
1099         else if (strncmp(p, "Offsets", 7) == 0) {
1100             TaskState *ts = s->c_cpu->opaque;
1101
1102             snprintf(buf, sizeof(buf),
1103                      "Text=" TARGET_ABI_FMT_lx ";Data=" TARGET_ABI_FMT_lx
1104                      ";Bss=" TARGET_ABI_FMT_lx,
1105                      ts->info->code_offset,
1106                      ts->info->data_offset,
1107                      ts->info->data_offset);
1108             put_packet(s, buf);
1109             break;
1110         }
1111 #else /* !CONFIG_USER_ONLY */
1112         else if (strncmp(p, "Rcmd,", 5) == 0) {
1113             int len = strlen(p + 5);
1114
1115             if ((len % 2) != 0) {
1116                 put_packet(s, "E01");
1117                 break;
1118             }
1119             hextomem(mem_buf, p + 5, len);
1120             len = len / 2;
1121             mem_buf[len++] = 0;
1122             qemu_chr_be_write(s->mon_chr, mem_buf, len);
1123             put_packet(s, "OK");
1124             break;
1125         }
1126 #endif /* !CONFIG_USER_ONLY */
1127         if (strncmp(p, "Supported", 9) == 0) {
1128             snprintf(buf, sizeof(buf), "PacketSize=%x", MAX_PACKET_LENGTH);
1129             cc = CPU_GET_CLASS(first_cpu);
1130             if (cc->gdb_core_xml_file != NULL) {
1131                 pstrcat(buf, sizeof(buf), ";qXfer:features:read+");
1132             }
1133             put_packet(s, buf);
1134             break;
1135         }
1136         if (strncmp(p, "Xfer:features:read:", 19) == 0) {
1137             const char *xml;
1138             target_ulong total_len;
1139
1140             cc = CPU_GET_CLASS(first_cpu);
1141             if (cc->gdb_core_xml_file == NULL) {
1142                 goto unknown_command;
1143             }
1144
1145             gdb_has_xml = true;
1146             p += 19;
1147             xml = get_feature_xml(p, &p, cc);
1148             if (!xml) {
1149                 snprintf(buf, sizeof(buf), "E00");
1150                 put_packet(s, buf);
1151                 break;
1152             }
1153
1154             if (*p == ':')
1155                 p++;
1156             addr = strtoul(p, (char **)&p, 16);
1157             if (*p == ',')
1158                 p++;
1159             len = strtoul(p, (char **)&p, 16);
1160
1161             total_len = strlen(xml);
1162             if (addr > total_len) {
1163                 snprintf(buf, sizeof(buf), "E00");
1164                 put_packet(s, buf);
1165                 break;
1166             }
1167             if (len > (MAX_PACKET_LENGTH - 5) / 2)
1168                 len = (MAX_PACKET_LENGTH - 5) / 2;
1169             if (len < total_len - addr) {
1170                 buf[0] = 'm';
1171                 len = memtox(buf + 1, xml + addr, len);
1172             } else {
1173                 buf[0] = 'l';
1174                 len = memtox(buf + 1, xml + addr, total_len - addr);
1175             }
1176             put_packet_binary(s, buf, len + 1);
1177             break;
1178         }
1179         /* Unrecognised 'q' command.  */
1180         goto unknown_command;
1181
1182     default:
1183     unknown_command:
1184         /* put empty packet */
1185         buf[0] = '\0';
1186         put_packet(s, buf);
1187         break;
1188     }
1189     return RS_IDLE;
1190 }
1191
1192 void gdb_set_stop_cpu(CPUState *cpu)
1193 {
1194     gdbserver_state->c_cpu = cpu;
1195     gdbserver_state->g_cpu = cpu;
1196 }
1197
1198 #ifndef CONFIG_USER_ONLY
1199 static void gdb_vm_state_change(void *opaque, int running, RunState state)
1200 {
1201     GDBState *s = gdbserver_state;
1202     CPUArchState *env = s->c_cpu->env_ptr;
1203     CPUState *cpu = s->c_cpu;
1204     char buf[256];
1205     const char *type;
1206     int ret;
1207
1208     if (running || s->state == RS_INACTIVE) {
1209         return;
1210     }
1211     /* Is there a GDB syscall waiting to be sent?  */
1212     if (s->current_syscall_cb) {
1213         put_packet(s, s->syscall_buf);
1214         return;
1215     }
1216     switch (state) {
1217     case RUN_STATE_DEBUG:
1218         if (cpu->watchpoint_hit) {
1219             switch (cpu->watchpoint_hit->flags & BP_MEM_ACCESS) {
1220             case BP_MEM_READ:
1221                 type = "r";
1222                 break;
1223             case BP_MEM_ACCESS:
1224                 type = "a";
1225                 break;
1226             default:
1227                 type = "";
1228                 break;
1229             }
1230             snprintf(buf, sizeof(buf),
1231                      "T%02xthread:%02x;%swatch:" TARGET_FMT_lx ";",
1232                      GDB_SIGNAL_TRAP, cpu_index(cpu), type,
1233                      (target_ulong)cpu->watchpoint_hit->vaddr);
1234             cpu->watchpoint_hit = NULL;
1235             goto send_packet;
1236         }
1237         tb_flush(env);
1238         ret = GDB_SIGNAL_TRAP;
1239         break;
1240     case RUN_STATE_PAUSED:
1241         ret = GDB_SIGNAL_INT;
1242         break;
1243     case RUN_STATE_SHUTDOWN:
1244         ret = GDB_SIGNAL_QUIT;
1245         break;
1246     case RUN_STATE_IO_ERROR:
1247         ret = GDB_SIGNAL_IO;
1248         break;
1249     case RUN_STATE_WATCHDOG:
1250         ret = GDB_SIGNAL_ALRM;
1251         break;
1252     case RUN_STATE_INTERNAL_ERROR:
1253         ret = GDB_SIGNAL_ABRT;
1254         break;
1255     case RUN_STATE_SAVE_VM:
1256     case RUN_STATE_RESTORE_VM:
1257         return;
1258     case RUN_STATE_FINISH_MIGRATE:
1259         ret = GDB_SIGNAL_XCPU;
1260         break;
1261     default:
1262         ret = GDB_SIGNAL_UNKNOWN;
1263         break;
1264     }
1265     snprintf(buf, sizeof(buf), "T%02xthread:%02x;", ret, cpu_index(cpu));
1266
1267 send_packet:
1268     put_packet(s, buf);
1269
1270     /* disable single step if it was enabled */
1271     cpu_single_step(cpu, 0);
1272 }
1273 #endif
1274
1275 /* Send a gdb syscall request.
1276    This accepts limited printf-style format specifiers, specifically:
1277     %x  - target_ulong argument printed in hex.
1278     %lx - 64-bit argument printed in hex.
1279     %s  - string pointer (target_ulong) and length (int) pair.  */
1280 void gdb_do_syscall(gdb_syscall_complete_cb cb, const char *fmt, ...)
1281 {
1282     va_list va;
1283     char *p;
1284     char *p_end;
1285     target_ulong addr;
1286     uint64_t i64;
1287     GDBState *s;
1288
1289     s = gdbserver_state;
1290     if (!s)
1291         return;
1292     s->current_syscall_cb = cb;
1293 #ifndef CONFIG_USER_ONLY
1294     vm_stop(RUN_STATE_DEBUG);
1295 #endif
1296     va_start(va, fmt);
1297     p = s->syscall_buf;
1298     p_end = &s->syscall_buf[sizeof(s->syscall_buf)];
1299     *(p++) = 'F';
1300     while (*fmt) {
1301         if (*fmt == '%') {
1302             fmt++;
1303             switch (*fmt++) {
1304             case 'x':
1305                 addr = va_arg(va, target_ulong);
1306                 p += snprintf(p, p_end - p, TARGET_FMT_lx, addr);
1307                 break;
1308             case 'l':
1309                 if (*(fmt++) != 'x')
1310                     goto bad_format;
1311                 i64 = va_arg(va, uint64_t);
1312                 p += snprintf(p, p_end - p, "%" PRIx64, i64);
1313                 break;
1314             case 's':
1315                 addr = va_arg(va, target_ulong);
1316                 p += snprintf(p, p_end - p, TARGET_FMT_lx "/%x",
1317                               addr, va_arg(va, int));
1318                 break;
1319             default:
1320             bad_format:
1321                 fprintf(stderr, "gdbstub: Bad syscall format string '%s'\n",
1322                         fmt - 1);
1323                 break;
1324             }
1325         } else {
1326             *(p++) = *(fmt++);
1327         }
1328     }
1329     *p = 0;
1330     va_end(va);
1331 #ifdef CONFIG_USER_ONLY
1332     put_packet(s, s->syscall_buf);
1333     gdb_handlesig(s->c_cpu, 0);
1334 #else
1335     /* In this case wait to send the syscall packet until notification that
1336        the CPU has stopped.  This must be done because if the packet is sent
1337        now the reply from the syscall request could be received while the CPU
1338        is still in the running state, which can cause packets to be dropped
1339        and state transition 'T' packets to be sent while the syscall is still
1340        being processed.  */
1341     cpu_exit(s->c_cpu);
1342 #endif
1343 }
1344
1345 static void gdb_read_byte(GDBState *s, int ch)
1346 {
1347     int i, csum;
1348     uint8_t reply;
1349
1350 #ifndef CONFIG_USER_ONLY
1351     if (s->last_packet_len) {
1352         /* Waiting for a response to the last packet.  If we see the start
1353            of a new command then abandon the previous response.  */
1354         if (ch == '-') {
1355 #ifdef DEBUG_GDB
1356             printf("Got NACK, retransmitting\n");
1357 #endif
1358             put_buffer(s, (uint8_t *)s->last_packet, s->last_packet_len);
1359         }
1360 #ifdef DEBUG_GDB
1361         else if (ch == '+')
1362             printf("Got ACK\n");
1363         else
1364             printf("Got '%c' when expecting ACK/NACK\n", ch);
1365 #endif
1366         if (ch == '+' || ch == '$')
1367             s->last_packet_len = 0;
1368         if (ch != '$')
1369             return;
1370     }
1371     if (runstate_is_running()) {
1372         /* when the CPU is running, we cannot do anything except stop
1373            it when receiving a char */
1374         vm_stop(RUN_STATE_PAUSED);
1375     } else
1376 #endif
1377     {
1378         switch(s->state) {
1379         case RS_IDLE:
1380             if (ch == '$') {
1381                 s->line_buf_index = 0;
1382                 s->state = RS_GETLINE;
1383             }
1384             break;
1385         case RS_GETLINE:
1386             if (ch == '#') {
1387             s->state = RS_CHKSUM1;
1388             } else if (s->line_buf_index >= sizeof(s->line_buf) - 1) {
1389                 s->state = RS_IDLE;
1390             } else {
1391             s->line_buf[s->line_buf_index++] = ch;
1392             }
1393             break;
1394         case RS_CHKSUM1:
1395             s->line_buf[s->line_buf_index] = '\0';
1396             s->line_csum = fromhex(ch) << 4;
1397             s->state = RS_CHKSUM2;
1398             break;
1399         case RS_CHKSUM2:
1400             s->line_csum |= fromhex(ch);
1401             csum = 0;
1402             for(i = 0; i < s->line_buf_index; i++) {
1403                 csum += s->line_buf[i];
1404             }
1405             if (s->line_csum != (csum & 0xff)) {
1406                 reply = '-';
1407                 put_buffer(s, &reply, 1);
1408                 s->state = RS_IDLE;
1409             } else {
1410                 reply = '+';
1411                 put_buffer(s, &reply, 1);
1412                 s->state = gdb_handle_packet(s, s->line_buf);
1413             }
1414             break;
1415         default:
1416             abort();
1417         }
1418     }
1419 }
1420
1421 /* Tell the remote gdb that the process has exited.  */
1422 void gdb_exit(CPUArchState *env, int code)
1423 {
1424   GDBState *s;
1425   char buf[4];
1426
1427   s = gdbserver_state;
1428   if (!s) {
1429       return;
1430   }
1431 #ifdef CONFIG_USER_ONLY
1432   if (gdbserver_fd < 0 || s->fd < 0) {
1433       return;
1434   }
1435 #endif
1436
1437   snprintf(buf, sizeof(buf), "W%02x", (uint8_t)code);
1438   put_packet(s, buf);
1439
1440 #ifndef CONFIG_USER_ONLY
1441   if (s->chr) {
1442       qemu_chr_delete(s->chr);
1443   }
1444 #endif
1445 }
1446
1447 #ifdef CONFIG_USER_ONLY
1448 int
1449 gdb_queuesig (void)
1450 {
1451     GDBState *s;
1452
1453     s = gdbserver_state;
1454
1455     if (gdbserver_fd < 0 || s->fd < 0)
1456         return 0;
1457     else
1458         return 1;
1459 }
1460
1461 int
1462 gdb_handlesig(CPUState *cpu, int sig)
1463 {
1464     CPUArchState *env = cpu->env_ptr;
1465     GDBState *s;
1466     char buf[256];
1467     int n;
1468
1469     s = gdbserver_state;
1470     if (gdbserver_fd < 0 || s->fd < 0) {
1471         return sig;
1472     }
1473
1474     /* disable single step if it was enabled */
1475     cpu_single_step(cpu, 0);
1476     tb_flush(env);
1477
1478     if (sig != 0) {
1479         snprintf(buf, sizeof(buf), "S%02x", target_signal_to_gdb(sig));
1480         put_packet(s, buf);
1481     }
1482     /* put_packet() might have detected that the peer terminated the
1483        connection.  */
1484     if (s->fd < 0) {
1485         return sig;
1486     }
1487
1488     sig = 0;
1489     s->state = RS_IDLE;
1490     s->running_state = 0;
1491     while (s->running_state == 0) {
1492         n = read(s->fd, buf, 256);
1493         if (n > 0) {
1494             int i;
1495
1496             for (i = 0; i < n; i++) {
1497                 gdb_read_byte(s, buf[i]);
1498             }
1499         } else if (n == 0 || errno != EAGAIN) {
1500             /* XXX: Connection closed.  Should probably wait for another
1501                connection before continuing.  */
1502             return sig;
1503         }
1504     }
1505     sig = s->signal;
1506     s->signal = 0;
1507     return sig;
1508 }
1509
1510 /* Tell the remote gdb that the process has exited due to SIG.  */
1511 void gdb_signalled(CPUArchState *env, int sig)
1512 {
1513     GDBState *s;
1514     char buf[4];
1515
1516     s = gdbserver_state;
1517     if (gdbserver_fd < 0 || s->fd < 0) {
1518         return;
1519     }
1520
1521     snprintf(buf, sizeof(buf), "X%02x", target_signal_to_gdb(sig));
1522     put_packet(s, buf);
1523 }
1524
1525 static void gdb_accept(void)
1526 {
1527     GDBState *s;
1528     struct sockaddr_in sockaddr;
1529     socklen_t len;
1530     int fd;
1531
1532     for(;;) {
1533         len = sizeof(sockaddr);
1534         fd = accept(gdbserver_fd, (struct sockaddr *)&sockaddr, &len);
1535         if (fd < 0 && errno != EINTR) {
1536             perror("accept");
1537             return;
1538         } else if (fd >= 0) {
1539 #ifndef _WIN32
1540             fcntl(fd, F_SETFD, FD_CLOEXEC);
1541 #endif
1542             break;
1543         }
1544     }
1545
1546     /* set short latency */
1547     socket_set_nodelay(fd);
1548
1549     s = g_malloc0(sizeof(GDBState));
1550     s->c_cpu = first_cpu;
1551     s->g_cpu = first_cpu;
1552     s->fd = fd;
1553     gdb_has_xml = false;
1554
1555     gdbserver_state = s;
1556
1557     fcntl(fd, F_SETFL, O_NONBLOCK);
1558 }
1559
1560 static int gdbserver_open(int port)
1561 {
1562     struct sockaddr_in sockaddr;
1563     int fd, ret;
1564
1565     fd = socket(PF_INET, SOCK_STREAM, 0);
1566     if (fd < 0) {
1567         perror("socket");
1568         return -1;
1569     }
1570 #ifndef _WIN32
1571     fcntl(fd, F_SETFD, FD_CLOEXEC);
1572 #endif
1573
1574     socket_set_fast_reuse(fd);
1575
1576     sockaddr.sin_family = AF_INET;
1577     sockaddr.sin_port = htons(port);
1578     sockaddr.sin_addr.s_addr = 0;
1579     ret = bind(fd, (struct sockaddr *)&sockaddr, sizeof(sockaddr));
1580     if (ret < 0) {
1581         perror("bind");
1582         close(fd);
1583         return -1;
1584     }
1585     ret = listen(fd, 0);
1586     if (ret < 0) {
1587         perror("listen");
1588         close(fd);
1589         return -1;
1590     }
1591     return fd;
1592 }
1593
1594 int gdbserver_start(int port)
1595 {
1596     gdbserver_fd = gdbserver_open(port);
1597     if (gdbserver_fd < 0)
1598         return -1;
1599     /* accept connections */
1600     gdb_accept();
1601     return 0;
1602 }
1603
1604 /* Disable gdb stub for child processes.  */
1605 void gdbserver_fork(CPUArchState *env)
1606 {
1607     CPUState *cpu = ENV_GET_CPU(env);
1608     GDBState *s = gdbserver_state;
1609
1610     if (gdbserver_fd < 0 || s->fd < 0) {
1611         return;
1612     }
1613     close(s->fd);
1614     s->fd = -1;
1615     cpu_breakpoint_remove_all(cpu, BP_GDB);
1616     cpu_watchpoint_remove_all(cpu, BP_GDB);
1617 }
1618 #else
1619 static int gdb_chr_can_receive(void *opaque)
1620 {
1621   /* We can handle an arbitrarily large amount of data.
1622    Pick the maximum packet size, which is as good as anything.  */
1623   return MAX_PACKET_LENGTH;
1624 }
1625
1626 static void gdb_chr_receive(void *opaque, const uint8_t *buf, int size)
1627 {
1628     int i;
1629
1630     for (i = 0; i < size; i++) {
1631         gdb_read_byte(gdbserver_state, buf[i]);
1632     }
1633 }
1634
1635 static void gdb_chr_event(void *opaque, int event)
1636 {
1637     switch (event) {
1638     case CHR_EVENT_OPENED:
1639         vm_stop(RUN_STATE_PAUSED);
1640         gdb_has_xml = false;
1641         break;
1642     default:
1643         break;
1644     }
1645 }
1646
1647 static void gdb_monitor_output(GDBState *s, const char *msg, int len)
1648 {
1649     char buf[MAX_PACKET_LENGTH];
1650
1651     buf[0] = 'O';
1652     if (len > (MAX_PACKET_LENGTH/2) - 1)
1653         len = (MAX_PACKET_LENGTH/2) - 1;
1654     memtohex(buf + 1, (uint8_t *)msg, len);
1655     put_packet(s, buf);
1656 }
1657
1658 static int gdb_monitor_write(CharDriverState *chr, const uint8_t *buf, int len)
1659 {
1660     const char *p = (const char *)buf;
1661     int max_sz;
1662
1663     max_sz = (sizeof(gdbserver_state->last_packet) - 2) / 2;
1664     for (;;) {
1665         if (len <= max_sz) {
1666             gdb_monitor_output(gdbserver_state, p, len);
1667             break;
1668         }
1669         gdb_monitor_output(gdbserver_state, p, max_sz);
1670         p += max_sz;
1671         len -= max_sz;
1672     }
1673     return len;
1674 }
1675
1676 #ifndef _WIN32
1677 static void gdb_sigterm_handler(int signal)
1678 {
1679     if (runstate_is_running()) {
1680         vm_stop(RUN_STATE_PAUSED);
1681     }
1682 }
1683 #endif
1684
1685 int gdbserver_start(const char *device)
1686 {
1687     GDBState *s;
1688     char gdbstub_device_name[128];
1689     CharDriverState *chr = NULL;
1690     CharDriverState *mon_chr;
1691
1692     if (!device)
1693         return -1;
1694     if (strcmp(device, "none") != 0) {
1695         if (strstart(device, "tcp:", NULL)) {
1696             /* enforce required TCP attributes */
1697             snprintf(gdbstub_device_name, sizeof(gdbstub_device_name),
1698                      "%s,nowait,nodelay,server", device);
1699             device = gdbstub_device_name;
1700         }
1701 #ifndef _WIN32
1702         else if (strcmp(device, "stdio") == 0) {
1703             struct sigaction act;
1704
1705             memset(&act, 0, sizeof(act));
1706             act.sa_handler = gdb_sigterm_handler;
1707             sigaction(SIGINT, &act, NULL);
1708         }
1709 #endif
1710         chr = qemu_chr_new("gdb", device, NULL);
1711         if (!chr)
1712             return -1;
1713
1714         qemu_chr_fe_claim_no_fail(chr);
1715         qemu_chr_add_handlers(chr, gdb_chr_can_receive, gdb_chr_receive,
1716                               gdb_chr_event, NULL);
1717     }
1718
1719     s = gdbserver_state;
1720     if (!s) {
1721         s = g_malloc0(sizeof(GDBState));
1722         gdbserver_state = s;
1723
1724         qemu_add_vm_change_state_handler(gdb_vm_state_change, NULL);
1725
1726         /* Initialize a monitor terminal for gdb */
1727         mon_chr = qemu_chr_alloc();
1728         mon_chr->chr_write = gdb_monitor_write;
1729         monitor_init(mon_chr, 0);
1730     } else {
1731         if (s->chr)
1732             qemu_chr_delete(s->chr);
1733         mon_chr = s->mon_chr;
1734         memset(s, 0, sizeof(GDBState));
1735     }
1736     s->c_cpu = first_cpu;
1737     s->g_cpu = first_cpu;
1738     s->chr = chr;
1739     s->state = chr ? RS_IDLE : RS_INACTIVE;
1740     s->mon_chr = mon_chr;
1741     s->current_syscall_cb = NULL;
1742
1743     return 0;
1744 }
1745 #endif