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