gdbstub.c

   1 /*
   2  * gdb server stub
   3  *
   4  * This implements a subset of the remote protocol as described in:
   5  *
   6  *   https://sourceware.org/gdb/onlinedocs/gdb/Remote-Protocol.html
   7  *
   8  * Copyright (c) 2003-2005 Fabrice Bellard
   9  *
  10  * This library is free software; you can redistribute it and/or
  11  * modify it under the terms of the GNU Lesser General Public
  12  * License as published by the Free Software Foundation; either
  13  * version 2 of the License, or (at your option) any later version.
  14  *
  15  * This library is distributed in the hope that it will be useful,
  16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  18  * Lesser General Public License for more details.
  19  *
  20  * You should have received a copy of the GNU Lesser General Public
  21  * License along with this library; if not, see <http://www.gnu.org/licenses/>.
  22  *
  23  * SPDX-License-Identifier: LGPL-2.0+
  24  */
  25
  26 #include "qemu/osdep.h"
  27 #include "qemu-common.h"
  28 #include "qapi/error.h"
  29 #include "qemu/error-report.h"
  30 #include "qemu/ctype.h"
  31 #include "qemu/cutils.h"
  32 #include "qemu/module.h"
  33 #include "trace/trace-root.h"
  34 #ifdef CONFIG_USER_ONLY
  35 #include "qemu.h"
  36 #else
  37 #include "monitor/monitor.h"
  38 #include "chardev/char.h"
  39 #include "chardev/char-fe.h"
  40 #include "exec/gdbstub.h"
  41 #include "hw/cpu/cluster.h"
  42 #include "hw/boards.h"
  43 #endif
  44
  45 #define MAX_PACKET_LENGTH 4096
  46
  47 #include "qemu/sockets.h"
  48 #include "sysemu/hw_accel.h"
  49 #include "sysemu/kvm.h"
  50 #include "sysemu/runstate.h"
  51 #include "semihosting/semihost.h"
  52 #include "exec/exec-all.h"
  53 #include "sysemu/replay.h"
  54
  55 #ifdef CONFIG_USER_ONLY
  56 #define GDB_ATTACHED "0"
  57 #else
  58 #define GDB_ATTACHED "1"
  59 #endif
  60
  61 #ifndef CONFIG_USER_ONLY
  62 static int phy_memory_mode;
  63 #endif
  64
  65 static inline int target_memory_rw_debug(CPUState *cpu, target_ulong addr,
  66                                          uint8_t *buf, int len, bool is_write)
  67 {
  68     CPUClass *cc;
  69
  70 #ifndef CONFIG_USER_ONLY
  71     if (phy_memory_mode) {
  72         if (is_write) {
  73             cpu_physical_memory_write(addr, buf, len);
  74         } else {
  75             cpu_physical_memory_read(addr, buf, len);
  76         }
  77         return 0;
  78     }
  79 #endif
  80
  81     cc = CPU_GET_CLASS(cpu);
  82     if (cc->memory_rw_debug) {
  83         return cc->memory_rw_debug(cpu, addr, buf, len, is_write);
  84     }
  85     return cpu_memory_rw_debug(cpu, addr, buf, len, is_write);
  86 }
  87
  88 /* Return the GDB index for a given vCPU state.
  89  *
  90  * For user mode this is simply the thread id. In system mode GDB
  91  * numbers CPUs from 1 as 0 is reserved as an "any cpu" index.
  92  */
  93 static inline int cpu_gdb_index(CPUState *cpu)
  94 {
  95 #if defined(CONFIG_USER_ONLY)
  96     TaskState *ts = (TaskState *) cpu->opaque;
  97     return ts->ts_tid;
  98 #else
  99     return cpu->cpu_index + 1;
 100 #endif
 101 }
 102
 103 enum {
 104     GDB_SIGNAL_0 = 0,
 105     GDB_SIGNAL_INT = 2,
 106     GDB_SIGNAL_QUIT = 3,
 107     GDB_SIGNAL_TRAP = 5,
 108     GDB_SIGNAL_ABRT = 6,
 109     GDB_SIGNAL_ALRM = 14,
 110     GDB_SIGNAL_IO = 23,
 111     GDB_SIGNAL_XCPU = 24,
 112     GDB_SIGNAL_UNKNOWN = 143
 113 };
 114
 115 #ifdef CONFIG_USER_ONLY
 116
 117 /* Map target signal numbers to GDB protocol signal numbers and vice
 118  * versa.  For user emulation's currently supported systems, we can
 119  * assume most signals are defined.
 120  */
 121
 122 static int gdb_signal_table[] = {
 123     0,
 124     TARGET_SIGHUP,
 125     TARGET_SIGINT,
 126     TARGET_SIGQUIT,
 127     TARGET_SIGILL,
 128     TARGET_SIGTRAP,
 129     TARGET_SIGABRT,
 130     -1, /* SIGEMT */
 131     TARGET_SIGFPE,
 132     TARGET_SIGKILL,
 133     TARGET_SIGBUS,
 134     TARGET_SIGSEGV,
 135     TARGET_SIGSYS,
 136     TARGET_SIGPIPE,
 137     TARGET_SIGALRM,
 138     TARGET_SIGTERM,
 139     TARGET_SIGURG,
 140     TARGET_SIGSTOP,
 141     TARGET_SIGTSTP,
 142     TARGET_SIGCONT,
 143     TARGET_SIGCHLD,
 144     TARGET_SIGTTIN,
 145     TARGET_SIGTTOU,
 146     TARGET_SIGIO,
 147     TARGET_SIGXCPU,
 148     TARGET_SIGXFSZ,
 149     TARGET_SIGVTALRM,
 150     TARGET_SIGPROF,
 151     TARGET_SIGWINCH,
 152     -1, /* SIGLOST */
 153     TARGET_SIGUSR1,
 154     TARGET_SIGUSR2,
 155 #ifdef TARGET_SIGPWR
 156     TARGET_SIGPWR,
 157 #else
 158     -1,
 159 #endif
 160     -1, /* SIGPOLL */
 161     -1,
 162     -1,
 163     -1,
 164     -1,
 165     -1,
 166     -1,
 167     -1,
 168     -1,
 169     -1,
 170     -1,
 171     -1,
 172 #ifdef __SIGRTMIN
 173     __SIGRTMIN + 1,
 174     __SIGRTMIN + 2,
 175     __SIGRTMIN + 3,
 176     __SIGRTMIN + 4,
 177     __SIGRTMIN + 5,
 178     __SIGRTMIN + 6,
 179     __SIGRTMIN + 7,
 180     __SIGRTMIN + 8,
 181     __SIGRTMIN + 9,
 182     __SIGRTMIN + 10,
 183     __SIGRTMIN + 11,
 184     __SIGRTMIN + 12,
 185     __SIGRTMIN + 13,
 186     __SIGRTMIN + 14,
 187     __SIGRTMIN + 15,
 188     __SIGRTMIN + 16,
 189     __SIGRTMIN + 17,
 190     __SIGRTMIN + 18,
 191     __SIGRTMIN + 19,
 192     __SIGRTMIN + 20,
 193     __SIGRTMIN + 21,
 194     __SIGRTMIN + 22,
 195     __SIGRTMIN + 23,
 196     __SIGRTMIN + 24,
 197     __SIGRTMIN + 25,
 198     __SIGRTMIN + 26,
 199     __SIGRTMIN + 27,
 200     __SIGRTMIN + 28,
 201     __SIGRTMIN + 29,
 202     __SIGRTMIN + 30,
 203     __SIGRTMIN + 31,
 204     -1, /* SIGCANCEL */
 205     __SIGRTMIN,
 206     __SIGRTMIN + 32,
 207     __SIGRTMIN + 33,
 208     __SIGRTMIN + 34,
 209     __SIGRTMIN + 35,
 210     __SIGRTMIN + 36,
 211     __SIGRTMIN + 37,
 212     __SIGRTMIN + 38,
 213     __SIGRTMIN + 39,
 214     __SIGRTMIN + 40,
 215     __SIGRTMIN + 41,
 216     __SIGRTMIN + 42,
 217     __SIGRTMIN + 43,
 218     __SIGRTMIN + 44,
 219     __SIGRTMIN + 45,
 220     __SIGRTMIN + 46,
 221     __SIGRTMIN + 47,
 222     __SIGRTMIN + 48,
 223     __SIGRTMIN + 49,
 224     __SIGRTMIN + 50,
 225     __SIGRTMIN + 51,
 226     __SIGRTMIN + 52,
 227     __SIGRTMIN + 53,
 228     __SIGRTMIN + 54,
 229     __SIGRTMIN + 55,
 230     __SIGRTMIN + 56,
 231     __SIGRTMIN + 57,
 232     __SIGRTMIN + 58,
 233     __SIGRTMIN + 59,
 234     __SIGRTMIN + 60,
 235     __SIGRTMIN + 61,
 236     __SIGRTMIN + 62,
 237     __SIGRTMIN + 63,
 238     __SIGRTMIN + 64,
 239     __SIGRTMIN + 65,
 240     __SIGRTMIN + 66,
 241     __SIGRTMIN + 67,
 242     __SIGRTMIN + 68,
 243     __SIGRTMIN + 69,
 244     __SIGRTMIN + 70,
 245     __SIGRTMIN + 71,
 246     __SIGRTMIN + 72,
 247     __SIGRTMIN + 73,
 248     __SIGRTMIN + 74,
 249     __SIGRTMIN + 75,
 250     __SIGRTMIN + 76,
 251     __SIGRTMIN + 77,
 252     __SIGRTMIN + 78,
 253     __SIGRTMIN + 79,
 254     __SIGRTMIN + 80,
 255     __SIGRTMIN + 81,
 256     __SIGRTMIN + 82,
 257     __SIGRTMIN + 83,
 258     __SIGRTMIN + 84,
 259     __SIGRTMIN + 85,
 260     __SIGRTMIN + 86,
 261     __SIGRTMIN + 87,
 262     __SIGRTMIN + 88,
 263     __SIGRTMIN + 89,
 264     __SIGRTMIN + 90,
 265     __SIGRTMIN + 91,
 266     __SIGRTMIN + 92,
 267     __SIGRTMIN + 93,
 268     __SIGRTMIN + 94,
 269     __SIGRTMIN + 95,
 270     -1, /* SIGINFO */
 271     -1, /* UNKNOWN */
 272     -1, /* DEFAULT */
 273     -1,
 274     -1,
 275     -1,
 276     -1,
 277     -1,
 278     -1
 279 #endif
 280 };
 281 #else
 282 /* In system mode we only need SIGINT and SIGTRAP; other signals
 283    are not yet supported.  */
 284
 285 enum {
 286     TARGET_SIGINT = 2,
 287     TARGET_SIGTRAP = 5
 288 };
 289
 290 static int gdb_signal_table[] = {
 291     -1,
 292     -1,
 293     TARGET_SIGINT,
 294     -1,
 295     -1,
 296     TARGET_SIGTRAP
 297 };
 298 #endif
 299
 300 #ifdef CONFIG_USER_ONLY
 301 static int target_signal_to_gdb (int sig)
 302 {
 303     int i;
 304     for (i = 0; i < ARRAY_SIZE (gdb_signal_table); i++)
 305         if (gdb_signal_table[i] == sig)
 306             return i;
 307     return GDB_SIGNAL_UNKNOWN;
 308 }
 309 #endif
 310
 311 static int gdb_signal_to_target (int sig)
 312 {
 313     if (sig < ARRAY_SIZE (gdb_signal_table))
 314         return gdb_signal_table[sig];
 315     else
 316         return -1;
 317 }
 318
 319 typedef struct GDBRegisterState {
 320     int base_reg;
 321     int num_regs;
 322     gdb_get_reg_cb get_reg;
 323     gdb_set_reg_cb set_reg;
 324     const char *xml;
 325     struct GDBRegisterState *next;
 326 } GDBRegisterState;
 327
 328 typedef struct GDBProcess {
 329     uint32_t pid;
 330     bool attached;
 331
 332     char target_xml[1024];
 333 } GDBProcess;
 334
 335 enum RSState {
 336     RS_INACTIVE,
 337     RS_IDLE,
 338     RS_GETLINE,
 339     RS_GETLINE_ESC,
 340     RS_GETLINE_RLE,
 341     RS_CHKSUM1,
 342     RS_CHKSUM2,
 343 };
 344 typedef struct GDBState {
 345     bool init;       /* have we been initialised? */
 346     CPUState *c_cpu; /* current CPU for step/continue ops */
 347     CPUState *g_cpu; /* current CPU for other ops */
 348     CPUState *query_cpu; /* for q{f|s}ThreadInfo */
 349     enum RSState state; /* parsing state */
 350     char line_buf[MAX_PACKET_LENGTH];
 351     int line_buf_index;
 352     int line_sum; /* running checksum */
 353     int line_csum; /* checksum at the end of the packet */
 354     GByteArray *last_packet;
 355     int signal;
 356 #ifdef CONFIG_USER_ONLY
 357     int fd;
 358     char *socket_path;
 359     int running_state;
 360 #else
 361     CharBackend chr;
 362     Chardev *mon_chr;
 363 #endif
 364     bool multiprocess;
 365     GDBProcess *processes;
 366     int process_num;
 367     char syscall_buf[256];
 368     gdb_syscall_complete_cb current_syscall_cb;
 369     GString *str_buf;
 370     GByteArray *mem_buf;
 371 } GDBState;
 372
 373 /* By default use no IRQs and no timers while single stepping so as to
 374  * make single stepping like an ICE HW step.
 375  */
 376 static int sstep_flags = SSTEP_ENABLE|SSTEP_NOIRQ|SSTEP_NOTIMER;
 377
 378 /* Retrieves flags for single step mode. */
 379 static int get_sstep_flags(void)
 380 {
 381     /*
 382      * In replay mode all events written into the log should be replayed.
 383      * That is why NOIRQ flag is removed in this mode.
 384      */
 385     if (replay_mode != REPLAY_MODE_NONE) {
 386         return SSTEP_ENABLE;
 387     } else {
 388         return sstep_flags;
 389     }
 390 }
 391
 392 static GDBState gdbserver_state;
 393
 394 static void init_gdbserver_state(void)
 395 {
 396     g_assert(!gdbserver_state.init);
 397     memset(&gdbserver_state, 0, sizeof(GDBState));
 398     gdbserver_state.init = true;
 399     gdbserver_state.str_buf = g_string_new(NULL);
 400     gdbserver_state.mem_buf = g_byte_array_sized_new(MAX_PACKET_LENGTH);
 401     gdbserver_state.last_packet = g_byte_array_sized_new(MAX_PACKET_LENGTH + 4);
 402 }
 403
 404 #ifndef CONFIG_USER_ONLY
 405 static void reset_gdbserver_state(void)
 406 {
 407     g_free(gdbserver_state.processes);
 408     gdbserver_state.processes = NULL;
 409     gdbserver_state.process_num = 0;
 410 }
 411 #endif
 412
 413 bool gdb_has_xml;
 414
 415 #ifdef CONFIG_USER_ONLY
 416
 417 static int get_char(void)
 418 {
 419     uint8_t ch;
 420     int ret;
 421
 422     for(;;) {
 423         ret = qemu_recv(gdbserver_state.fd, &ch, 1, 0);
 424         if (ret < 0) {
 425             if (errno == ECONNRESET)
 426                 gdbserver_state.fd = -1;
 427             if (errno != EINTR)
 428                 return -1;
 429         } else if (ret == 0) {
 430             close(gdbserver_state.fd);
 431             gdbserver_state.fd = -1;
 432             return -1;
 433         } else {
 434             break;
 435         }
 436     }
 437     return ch;
 438 }
 439 #endif
 440
 441 static enum {
 442     GDB_SYS_UNKNOWN,
 443     GDB_SYS_ENABLED,
 444     GDB_SYS_DISABLED,
 445 } gdb_syscall_mode;
 446
 447 /* Decide if either remote gdb syscalls or native file IO should be used. */
 448 int use_gdb_syscalls(void)
 449 {
 450     SemihostingTarget target = semihosting_get_target();
 451     if (target == SEMIHOSTING_TARGET_NATIVE) {
 452         /* -semihosting-config target=native */
 453         return false;
 454     } else if (target == SEMIHOSTING_TARGET_GDB) {
 455         /* -semihosting-config target=gdb */
 456         return true;
 457     }
 458
 459     /* -semihosting-config target=auto */
 460     /* On the first call check if gdb is connected and remember. */
 461     if (gdb_syscall_mode == GDB_SYS_UNKNOWN) {
 462         gdb_syscall_mode = gdbserver_state.init ?
 463             GDB_SYS_ENABLED : GDB_SYS_DISABLED;
 464     }
 465     return gdb_syscall_mode == GDB_SYS_ENABLED;
 466 }
 467
 468 /* Resume execution.  */
 469 static inline void gdb_continue(void)
 470 {
 471
 472 #ifdef CONFIG_USER_ONLY
 473     gdbserver_state.running_state = 1;
 474     trace_gdbstub_op_continue();
 475 #else
 476     if (!runstate_needs_reset()) {
 477         trace_gdbstub_op_continue();
 478         vm_start();
 479     }
 480 #endif
 481 }
 482
 483 /*
 484  * Resume execution, per CPU actions. For user-mode emulation it's
 485  * equivalent to gdb_continue.
 486  */
 487 static int gdb_continue_partial(char *newstates)
 488 {
 489     CPUState *cpu;
 490     int res = 0;
 491 #ifdef CONFIG_USER_ONLY
 492     /*
 493      * This is not exactly accurate, but it's an improvement compared to the
 494      * previous situation, where only one CPU would be single-stepped.
 495      */
 496     CPU_FOREACH(cpu) {
 497         if (newstates[cpu->cpu_index] == 's') {
 498             trace_gdbstub_op_stepping(cpu->cpu_index);
 499             cpu_single_step(cpu, sstep_flags);
 500         }
 501     }
 502     gdbserver_state.running_state = 1;
 503 #else
 504     int flag = 0;
 505
 506     if (!runstate_needs_reset()) {
 507         if (vm_prepare_start()) {
 508             return 0;
 509         }
 510
 511         CPU_FOREACH(cpu) {
 512             switch (newstates[cpu->cpu_index]) {
 513             case 0:
 514             case 1:
 515                 break; /* nothing to do here */
 516             case 's':
 517                 trace_gdbstub_op_stepping(cpu->cpu_index);
 518                 cpu_single_step(cpu, get_sstep_flags());
 519                 cpu_resume(cpu);
 520                 flag = 1;
 521                 break;
 522             case 'c':
 523                 trace_gdbstub_op_continue_cpu(cpu->cpu_index);
 524                 cpu_resume(cpu);
 525                 flag = 1;
 526                 break;
 527             default:
 528                 res = -1;
 529                 break;
 530             }
 531         }
 532     }
 533     if (flag) {
 534         qemu_clock_enable(QEMU_CLOCK_VIRTUAL, true);
 535     }
 536 #endif
 537     return res;
 538 }
 539
 540 static void put_buffer(const uint8_t *buf, int len)
 541 {
 542 #ifdef CONFIG_USER_ONLY
 543     int ret;
 544
 545     while (len > 0) {
 546         ret = send(gdbserver_state.fd, buf, len, 0);
 547         if (ret < 0) {
 548             if (errno != EINTR)
 549                 return;
 550         } else {
 551             buf += ret;
 552             len -= ret;
 553         }
 554     }
 555 #else
 556     /* XXX this blocks entire thread. Rewrite to use
 557      * qemu_chr_fe_write and background I/O callbacks */
 558     qemu_chr_fe_write_all(&gdbserver_state.chr, buf, len);
 559 #endif
 560 }
 561
 562 static inline int fromhex(int v)
 563 {
 564     if (v >= '0' && v <= '9')
 565         return v - '0';
 566     else if (v >= 'A' && v <= 'F')
 567         return v - 'A' + 10;
 568     else if (v >= 'a' && v <= 'f')
 569         return v - 'a' + 10;
 570     else
 571         return 0;
 572 }
 573
 574 static inline int tohex(int v)
 575 {
 576     if (v < 10)
 577         return v + '0';
 578     else
 579         return v - 10 + 'a';
 580 }
 581
 582 /* writes 2*len+1 bytes in buf */
 583 static void memtohex(GString *buf, const uint8_t *mem, int len)
 584 {
 585     int i, c;
 586     for(i = 0; i < len; i++) {
 587         c = mem[i];
 588         g_string_append_c(buf, tohex(c >> 4));
 589         g_string_append_c(buf, tohex(c & 0xf));
 590     }
 591     g_string_append_c(buf, '\0');
 592 }
 593
 594 static void hextomem(GByteArray *mem, const char *buf, int len)
 595 {
 596     int i;
 597
 598     for(i = 0; i < len; i++) {
 599         guint8 byte = fromhex(buf[0]) << 4 | fromhex(buf[1]);
 600         g_byte_array_append(mem, &byte, 1);
 601         buf += 2;
 602     }
 603 }
 604
 605 static void hexdump(const char *buf, int len,
 606                     void (*trace_fn)(size_t ofs, char const *text))
 607 {
 608     char line_buffer[3 * 16 + 4 + 16 + 1];
 609
 610     size_t i;
 611     for (i = 0; i < len || (i & 0xF); ++i) {
 612         size_t byte_ofs = i & 15;
 613
 614         if (byte_ofs == 0) {
 615             memset(line_buffer, ' ', 3 * 16 + 4 + 16);
 616             line_buffer[3 * 16 + 4 + 16] = 0;
 617         }
 618
 619         size_t col_group = (i >> 2) & 3;
 620         size_t hex_col = byte_ofs * 3 + col_group;
 621         size_t txt_col = 3 * 16 + 4 + byte_ofs;
 622
 623         if (i < len) {
 624             char value = buf[i];
 625
 626             line_buffer[hex_col + 0] = tohex((value >> 4) & 0xF);
 627             line_buffer[hex_col + 1] = tohex((value >> 0) & 0xF);
 628             line_buffer[txt_col + 0] = (value >= ' ' && value < 127)
 629                     ? value
 630                     : '.';
 631         }
 632
 633         if (byte_ofs == 0xF)
 634             trace_fn(i & -16, line_buffer);
 635     }
 636 }
 637
 638 /* return -1 if error, 0 if OK */
 639 static int put_packet_binary(const char *buf, int len, bool dump)
 640 {
 641     int csum, i;
 642     uint8_t footer[3];
 643
 644     if (dump && trace_event_get_state_backends(TRACE_GDBSTUB_IO_BINARYREPLY)) {
 645         hexdump(buf, len, trace_gdbstub_io_binaryreply);
 646     }
 647
 648     for(;;) {
 649         g_byte_array_set_size(gdbserver_state.last_packet, 0);
 650         g_byte_array_append(gdbserver_state.last_packet,
 651                             (const uint8_t *) "$", 1);
 652         g_byte_array_append(gdbserver_state.last_packet,
 653                             (const uint8_t *) buf, len);
 654         csum = 0;
 655         for(i = 0; i < len; i++) {
 656             csum += buf[i];
 657         }
 658         footer[0] = '#';
 659         footer[1] = tohex((csum >> 4) & 0xf);
 660         footer[2] = tohex((csum) & 0xf);
 661         g_byte_array_append(gdbserver_state.last_packet, footer, 3);
 662
 663         put_buffer(gdbserver_state.last_packet->data,
 664                    gdbserver_state.last_packet->len);
 665
 666 #ifdef CONFIG_USER_ONLY
 667         i = get_char();
 668         if (i < 0)
 669             return -1;
 670         if (i == '+')
 671             break;
 672 #else
 673         break;
 674 #endif
 675     }
 676     return 0;
 677 }
 678
 679 /* return -1 if error, 0 if OK */
 680 static int put_packet(const char *buf)
 681 {
 682     trace_gdbstub_io_reply(buf);
 683
 684     return put_packet_binary(buf, strlen(buf), false);
 685 }
 686
 687 static void put_strbuf(void)
 688 {
 689     put_packet(gdbserver_state.str_buf->str);
 690 }
 691
 692 /* Encode data using the encoding for 'x' packets.  */
 693 static void memtox(GString *buf, const char *mem, int len)
 694 {
 695     char c;
 696
 697     while (len--) {
 698         c = *(mem++);
 699         switch (c) {
 700         case '#': case '$': case '*': case '}':
 701             g_string_append_c(buf, '}');
 702             g_string_append_c(buf, c ^ 0x20);
 703             break;
 704         default:
 705             g_string_append_c(buf, c);
 706             break;
 707         }
 708     }
 709 }
 710
 711 static uint32_t gdb_get_cpu_pid(CPUState *cpu)
 712 {
 713     /* TODO: In user mode, we should use the task state PID */
 714     if (cpu->cluster_index == UNASSIGNED_CLUSTER_INDEX) {
 715         /* Return the default process' PID */
 716         int index = gdbserver_state.process_num - 1;
 717         return gdbserver_state.processes[index].pid;
 718     }
 719     return cpu->cluster_index + 1;
 720 }
 721
 722 static GDBProcess *gdb_get_process(uint32_t pid)
 723 {
 724     int i;
 725
 726     if (!pid) {
 727         /* 0 means any process, we take the first one */
 728         return &gdbserver_state.processes[0];
 729     }
 730
 731     for (i = 0; i < gdbserver_state.process_num; i++) {
 732         if (gdbserver_state.processes[i].pid == pid) {
 733             return &gdbserver_state.processes[i];
 734         }
 735     }
 736
 737     return NULL;
 738 }
 739
 740 static GDBProcess *gdb_get_cpu_process(CPUState *cpu)
 741 {
 742     return gdb_get_process(gdb_get_cpu_pid(cpu));
 743 }
 744
 745 static CPUState *find_cpu(uint32_t thread_id)
 746 {
 747     CPUState *cpu;
 748
 749     CPU_FOREACH(cpu) {
 750         if (cpu_gdb_index(cpu) == thread_id) {
 751             return cpu;
 752         }
 753     }
 754
 755     return NULL;
 756 }
 757
 758 static CPUState *get_first_cpu_in_process(GDBProcess *process)
 759 {
 760     CPUState *cpu;
 761
 762     CPU_FOREACH(cpu) {
 763         if (gdb_get_cpu_pid(cpu) == process->pid) {
 764             return cpu;
 765         }
 766     }
 767
 768     return NULL;
 769 }
 770
 771 static CPUState *gdb_next_cpu_in_process(CPUState *cpu)
 772 {
 773     uint32_t pid = gdb_get_cpu_pid(cpu);
 774     cpu = CPU_NEXT(cpu);
 775
 776     while (cpu) {
 777         if (gdb_get_cpu_pid(cpu) == pid) {
 778             break;
 779         }
 780
 781         cpu = CPU_NEXT(cpu);
 782     }
 783
 784     return cpu;
 785 }
 786
 787 /* Return the cpu following @cpu, while ignoring unattached processes. */
 788 static CPUState *gdb_next_attached_cpu(CPUState *cpu)
 789 {
 790     cpu = CPU_NEXT(cpu);
 791
 792     while (cpu) {
 793         if (gdb_get_cpu_process(cpu)->attached) {
 794             break;
 795         }
 796
 797         cpu = CPU_NEXT(cpu);
 798     }
 799
 800     return cpu;
 801 }
 802
 803 /* Return the first attached cpu */
 804 static CPUState *gdb_first_attached_cpu(void)
 805 {
 806     CPUState *cpu = first_cpu;
 807     GDBProcess *process = gdb_get_cpu_process(cpu);
 808
 809     if (!process->attached) {
 810         return gdb_next_attached_cpu(cpu);
 811     }
 812
 813     return cpu;
 814 }
 815
 816 static CPUState *gdb_get_cpu(uint32_t pid, uint32_t tid)
 817 {
 818     GDBProcess *process;
 819     CPUState *cpu;
 820
 821     if (!pid && !tid) {
 822         /* 0 means any process/thread, we take the first attached one */
 823         return gdb_first_attached_cpu();
 824     } else if (pid && !tid) {
 825         /* any thread in a specific process */
 826         process = gdb_get_process(pid);
 827
 828         if (process == NULL) {
 829             return NULL;
 830         }
 831
 832         if (!process->attached) {
 833             return NULL;
 834         }
 835
 836         return get_first_cpu_in_process(process);
 837     } else {
 838         /* a specific thread */
 839         cpu = find_cpu(tid);
 840
 841         if (cpu == NULL) {
 842             return NULL;
 843         }
 844
 845         process = gdb_get_cpu_process(cpu);
 846
 847         if (pid && process->pid != pid) {
 848             return NULL;
 849         }
 850
 851         if (!process->attached) {
 852             return NULL;
 853         }
 854
 855         return cpu;
 856     }
 857 }
 858
 859 static const char *get_feature_xml(const char *p, const char **newp,
 860                                    GDBProcess *process)
 861 {
 862     size_t len;
 863     int i;
 864     const char *name;
 865     CPUState *cpu = get_first_cpu_in_process(process);
 866     CPUClass *cc = CPU_GET_CLASS(cpu);
 867
 868     len = 0;
 869     while (p[len] && p[len] != ':')
 870         len++;
 871     *newp = p + len;
 872
 873     name = NULL;
 874     if (strncmp(p, "target.xml", len) == 0) {
 875         char *buf = process->target_xml;
 876         const size_t buf_sz = sizeof(process->target_xml);
 877
 878         /* Generate the XML description for this CPU.  */
 879         if (!buf[0]) {
 880             GDBRegisterState *r;
 881
 882             pstrcat(buf, buf_sz,
 883                     "<?xml version=\"1.0\"?>"
 884                     "<!DOCTYPE target SYSTEM \"gdb-target.dtd\">"
 885                     "<target>");
 886             if (cc->gdb_arch_name) {
 887                 gchar *arch = cc->gdb_arch_name(cpu);
 888                 pstrcat(buf, buf_sz, "<architecture>");
 889                 pstrcat(buf, buf_sz, arch);
 890                 pstrcat(buf, buf_sz, "</architecture>");
 891                 g_free(arch);
 892             }
 893             pstrcat(buf, buf_sz, "<xi:include href=\"");
 894             pstrcat(buf, buf_sz, cc->gdb_core_xml_file);
 895             pstrcat(buf, buf_sz, "\"/>");
 896             for (r = cpu->gdb_regs; r; r = r->next) {
 897                 pstrcat(buf, buf_sz, "<xi:include href=\"");
 898                 pstrcat(buf, buf_sz, r->xml);
 899                 pstrcat(buf, buf_sz, "\"/>");
 900             }
 901             pstrcat(buf, buf_sz, "</target>");
 902         }
 903         return buf;
 904     }
 905     if (cc->gdb_get_dynamic_xml) {
 906         char *xmlname = g_strndup(p, len);
 907         const char *xml = cc->gdb_get_dynamic_xml(cpu, xmlname);
 908
 909         g_free(xmlname);
 910         if (xml) {
 911             return xml;
 912         }
 913     }
 914     for (i = 0; ; i++) {
 915         name = xml_builtin[i][0];
 916         if (!name || (strncmp(name, p, len) == 0 && strlen(name) == len))
 917             break;
 918     }
 919     return name ? xml_builtin[i][1] : NULL;
 920 }
 921
 922 static int gdb_read_register(CPUState *cpu, GByteArray *buf, int reg)
 923 {
 924     CPUClass *cc = CPU_GET_CLASS(cpu);
 925     CPUArchState *env = cpu->env_ptr;
 926     GDBRegisterState *r;
 927
 928     if (reg < cc->gdb_num_core_regs) {
 929         return cc->gdb_read_register(cpu, buf, reg);
 930     }
 931
 932     for (r = cpu->gdb_regs; r; r = r->next) {
 933         if (r->base_reg <= reg && reg < r->base_reg + r->num_regs) {
 934             return r->get_reg(env, buf, reg - r->base_reg);
 935         }
 936     }
 937     return 0;
 938 }
 939
 940 static int gdb_write_register(CPUState *cpu, uint8_t *mem_buf, int reg)
 941 {
 942     CPUClass *cc = CPU_GET_CLASS(cpu);
 943     CPUArchState *env = cpu->env_ptr;
 944     GDBRegisterState *r;
 945
 946     if (reg < cc->gdb_num_core_regs) {
 947         return cc->gdb_write_register(cpu, mem_buf, reg);
 948     }
 949
 950     for (r = cpu->gdb_regs; r; r = r->next) {
 951         if (r->base_reg <= reg && reg < r->base_reg + r->num_regs) {
 952             return r->set_reg(env, mem_buf, reg - r->base_reg);
 953         }
 954     }
 955     return 0;
 956 }
 957
 958 /* Register a supplemental set of CPU registers.  If g_pos is nonzero it
 959    specifies the first register number and these registers are included in
 960    a standard "g" packet.  Direction is relative to gdb, i.e. get_reg is
 961    gdb reading a CPU register, and set_reg is gdb modifying a CPU register.
 962  */
 963
 964 void gdb_register_coprocessor(CPUState *cpu,
 965                               gdb_get_reg_cb get_reg, gdb_set_reg_cb set_reg,
 966                               int num_regs, const char *xml, int g_pos)
 967 {
 968     GDBRegisterState *s;
 969     GDBRegisterState **p;
 970
 971     p = &cpu->gdb_regs;
 972     while (*p) {
 973         /* Check for duplicates.  */
 974         if (strcmp((*p)->xml, xml) == 0)
 975             return;
 976         p = &(*p)->next;
 977     }
 978
 979     s = g_new0(GDBRegisterState, 1);
 980     s->base_reg = cpu->gdb_num_regs;
 981     s->num_regs = num_regs;
 982     s->get_reg = get_reg;
 983     s->set_reg = set_reg;
 984     s->xml = xml;
 985
 986     /* Add to end of list.  */
 987     cpu->gdb_num_regs += num_regs;
 988     *p = s;
 989     if (g_pos) {
 990         if (g_pos != s->base_reg) {
 991             error_report("Error: Bad gdb register numbering for '%s', "
 992                          "expected %d got %d", xml, g_pos, s->base_reg);
 993         } else {
 994             cpu->gdb_num_g_regs = cpu->gdb_num_regs;
 995         }
 996     }
 997 }
 998
 999 #ifndef CONFIG_USER_ONLY
1000 /* Translate GDB watchpoint type to a flags value for cpu_watchpoint_* */
1001 static inline int xlat_gdb_type(CPUState *cpu, int gdbtype)
1002 {
1003     static const int xlat[] = {
1004         [GDB_WATCHPOINT_WRITE]  = BP_GDB | BP_MEM_WRITE,
1005         [GDB_WATCHPOINT_READ]   = BP_GDB | BP_MEM_READ,
1006         [GDB_WATCHPOINT_ACCESS] = BP_GDB | BP_MEM_ACCESS,
1007     };
1008
1009     CPUClass *cc = CPU_GET_CLASS(cpu);
1010     int cputype = xlat[gdbtype];
1011
1012     if (cc->gdb_stop_before_watchpoint) {
1013         cputype |= BP_STOP_BEFORE_ACCESS;
1014     }
1015     return cputype;
1016 }
1017 #endif
1018
1019 static int gdb_breakpoint_insert(int type, target_ulong addr, target_ulong len)
1020 {
1021     CPUState *cpu;
1022     int err = 0;
1023
1024     if (kvm_enabled()) {
1025         return kvm_insert_breakpoint(gdbserver_state.c_cpu, addr, len, type);
1026     }
1027
1028     switch (type) {
1029     case GDB_BREAKPOINT_SW:
1030     case GDB_BREAKPOINT_HW:
1031         CPU_FOREACH(cpu) {
1032             err = cpu_breakpoint_insert(cpu, addr, BP_GDB, NULL);
1033             if (err) {
1034                 break;
1035             }
1036         }
1037         return err;
1038 #ifndef CONFIG_USER_ONLY
1039     case GDB_WATCHPOINT_WRITE:
1040     case GDB_WATCHPOINT_READ:
1041     case GDB_WATCHPOINT_ACCESS:
1042         CPU_FOREACH(cpu) {
1043             err = cpu_watchpoint_insert(cpu, addr, len,
1044                                         xlat_gdb_type(cpu, type), NULL);
1045             if (err) {
1046                 break;
1047             }
1048         }
1049         return err;
1050 #endif
1051     default:
1052         return -ENOSYS;
1053     }
1054 }
1055
1056 static int gdb_breakpoint_remove(int type, target_ulong addr, target_ulong len)
1057 {
1058     CPUState *cpu;
1059     int err = 0;
1060
1061     if (kvm_enabled()) {
1062         return kvm_remove_breakpoint(gdbserver_state.c_cpu, addr, len, type);
1063     }
1064
1065     switch (type) {
1066     case GDB_BREAKPOINT_SW:
1067     case GDB_BREAKPOINT_HW:
1068         CPU_FOREACH(cpu) {
1069             err = cpu_breakpoint_remove(cpu, addr, BP_GDB);
1070             if (err) {
1071                 break;
1072             }
1073         }
1074         return err;
1075 #ifndef CONFIG_USER_ONLY
1076     case GDB_WATCHPOINT_WRITE:
1077     case GDB_WATCHPOINT_READ:
1078     case GDB_WATCHPOINT_ACCESS:
1079         CPU_FOREACH(cpu) {
1080             err = cpu_watchpoint_remove(cpu, addr, len,
1081                                         xlat_gdb_type(cpu, type));
1082             if (err)
1083                 break;
1084         }
1085         return err;
1086 #endif
1087     default:
1088         return -ENOSYS;
1089     }
1090 }
1091
1092 static inline void gdb_cpu_breakpoint_remove_all(CPUState *cpu)
1093 {
1094     cpu_breakpoint_remove_all(cpu, BP_GDB);
1095 #ifndef CONFIG_USER_ONLY
1096     cpu_watchpoint_remove_all(cpu, BP_GDB);
1097 #endif
1098 }
1099
1100 static void gdb_process_breakpoint_remove_all(GDBProcess *p)
1101 {
1102     CPUState *cpu = get_first_cpu_in_process(p);
1103
1104     while (cpu) {
1105         gdb_cpu_breakpoint_remove_all(cpu);
1106         cpu = gdb_next_cpu_in_process(cpu);
1107     }
1108 }
1109
1110 static void gdb_breakpoint_remove_all(void)
1111 {
1112     CPUState *cpu;
1113
1114     if (kvm_enabled()) {
1115         kvm_remove_all_breakpoints(gdbserver_state.c_cpu);
1116         return;
1117     }
1118
1119     CPU_FOREACH(cpu) {
1120         gdb_cpu_breakpoint_remove_all(cpu);
1121     }
1122 }
1123
1124 static void gdb_set_cpu_pc(target_ulong pc)
1125 {
1126     CPUState *cpu = gdbserver_state.c_cpu;
1127
1128     cpu_synchronize_state(cpu);
1129     cpu_set_pc(cpu, pc);
1130 }
1131
1132 static void gdb_append_thread_id(CPUState *cpu, GString *buf)
1133 {
1134     if (gdbserver_state.multiprocess) {
1135         g_string_append_printf(buf, "p%02x.%02x",
1136                                gdb_get_cpu_pid(cpu), cpu_gdb_index(cpu));
1137     } else {
1138         g_string_append_printf(buf, "%02x", cpu_gdb_index(cpu));
1139     }
1140 }
1141
1142 typedef enum GDBThreadIdKind {
1143     GDB_ONE_THREAD = 0,
1144     GDB_ALL_THREADS,     /* One process, all threads */
1145     GDB_ALL_PROCESSES,
1146     GDB_READ_THREAD_ERR
1147 } GDBThreadIdKind;
1148
1149 static GDBThreadIdKind read_thread_id(const char *buf, const char **end_buf,
1150                                       uint32_t *pid, uint32_t *tid)
1151 {
1152     unsigned long p, t;
1153     int ret;
1154
1155     if (*buf == 'p') {
1156         buf++;
1157         ret = qemu_strtoul(buf, &buf, 16, &p);
1158
1159         if (ret) {
1160             return GDB_READ_THREAD_ERR;
1161         }
1162
1163         /* Skip '.' */
1164         buf++;
1165     } else {
1166         p = 1;
1167     }
1168
1169     ret = qemu_strtoul(buf, &buf, 16, &t);
1170
1171     if (ret) {
1172         return GDB_READ_THREAD_ERR;
1173     }
1174
1175     *end_buf = buf;
1176
1177     if (p == -1) {
1178         return GDB_ALL_PROCESSES;
1179     }
1180
1181     if (pid) {
1182         *pid = p;
1183     }
1184
1185     if (t == -1) {
1186         return GDB_ALL_THREADS;
1187     }
1188
1189     if (tid) {
1190         *tid = t;
1191     }
1192
1193     return GDB_ONE_THREAD;
1194 }
1195
1196 /**
1197  * gdb_handle_vcont - Parses and handles a vCont packet.
1198  * returns -ENOTSUP if a command is unsupported, -EINVAL or -ERANGE if there is
1199  *         a format error, 0 on success.
1200  */
1201 static int gdb_handle_vcont(const char *p)
1202 {
1203     int res, signal = 0;
1204     char cur_action;
1205     char *newstates;
1206     unsigned long tmp;
1207     uint32_t pid, tid;
1208     GDBProcess *process;
1209     CPUState *cpu;
1210     GDBThreadIdKind kind;
1211 #ifdef CONFIG_USER_ONLY
1212     int max_cpus = 1; /* global variable max_cpus exists only in system mode */
1213
1214     CPU_FOREACH(cpu) {
1215         max_cpus = max_cpus <= cpu->cpu_index ? cpu->cpu_index + 1 : max_cpus;
1216     }
1217 #else
1218     MachineState *ms = MACHINE(qdev_get_machine());
1219     unsigned int max_cpus = ms->smp.max_cpus;
1220 #endif
1221     /* uninitialised CPUs stay 0 */
1222     newstates = g_new0(char, max_cpus);
1223
1224     /* mark valid CPUs with 1 */
1225     CPU_FOREACH(cpu) {
1226         newstates[cpu->cpu_index] = 1;
1227     }
1228
1229     /*
1230      * res keeps track of what error we are returning, with -ENOTSUP meaning
1231      * that the command is unknown or unsupported, thus returning an empty
1232      * packet, while -EINVAL and -ERANGE cause an E22 packet, due to invalid,
1233      *  or incorrect parameters passed.
1234      */
1235     res = 0;
1236     while (*p) {
1237         if (*p++ != ';') {
1238             res = -ENOTSUP;
1239             goto out;
1240         }
1241
1242         cur_action = *p++;
1243         if (cur_action == 'C' || cur_action == 'S') {
1244             cur_action = qemu_tolower(cur_action);
1245             res = qemu_strtoul(p, &p, 16, &tmp);
1246             if (res) {
1247                 goto out;
1248             }
1249             signal = gdb_signal_to_target(tmp);
1250         } else if (cur_action != 'c' && cur_action != 's') {
1251             /* unknown/invalid/unsupported command */
1252             res = -ENOTSUP;
1253             goto out;
1254         }
1255
1256         if (*p == '\0' || *p == ';') {
1257             /*
1258              * No thread specifier, action is on "all threads". The
1259              * specification is unclear regarding the process to act on. We
1260              * choose all processes.
1261              */
1262             kind = GDB_ALL_PROCESSES;
1263         } else if (*p++ == ':') {
1264             kind = read_thread_id(p, &p, &pid, &tid);
1265         } else {
1266             res = -ENOTSUP;
1267             goto out;
1268         }
1269
1270         switch (kind) {
1271         case GDB_READ_THREAD_ERR:
1272             res = -EINVAL;
1273             goto out;
1274
1275         case GDB_ALL_PROCESSES:
1276             cpu = gdb_first_attached_cpu();
1277             while (cpu) {
1278                 if (newstates[cpu->cpu_index] == 1) {
1279                     newstates[cpu->cpu_index] = cur_action;
1280                 }
1281
1282                 cpu = gdb_next_attached_cpu(cpu);
1283             }
1284             break;
1285
1286         case GDB_ALL_THREADS:
1287             process = gdb_get_process(pid);
1288
1289             if (!process->attached) {
1290                 res = -EINVAL;
1291                 goto out;
1292             }
1293
1294             cpu = get_first_cpu_in_process(process);
1295             while (cpu) {
1296                 if (newstates[cpu->cpu_index] == 1) {
1297                     newstates[cpu->cpu_index] = cur_action;
1298                 }
1299
1300                 cpu = gdb_next_cpu_in_process(cpu);
1301             }
1302             break;
1303
1304         case GDB_ONE_THREAD:
1305             cpu = gdb_get_cpu(pid, tid);
1306
1307             /* invalid CPU/thread specified */
1308             if (!cpu) {
1309                 res = -EINVAL;
1310                 goto out;
1311             }
1312
1313             /* only use if no previous match occourred */
1314             if (newstates[cpu->cpu_index] == 1) {
1315                 newstates[cpu->cpu_index] = cur_action;
1316             }
1317             break;
1318         }
1319     }
1320     gdbserver_state.signal = signal;
1321     gdb_continue_partial(newstates);
1322
1323 out:
1324     g_free(newstates);
1325
1326     return res;
1327 }
1328
1329 typedef union GdbCmdVariant {
1330     const char *data;
1331     uint8_t opcode;
1332     unsigned long val_ul;
1333     unsigned long long val_ull;
1334     struct {
1335         GDBThreadIdKind kind;
1336         uint32_t pid;
1337         uint32_t tid;
1338     } thread_id;
1339 } GdbCmdVariant;
1340
1341 static const char *cmd_next_param(const char *param, const char delimiter)
1342 {
1343     static const char all_delimiters[] = ",;:=";
1344     char curr_delimiters[2] = {0};
1345     const char *delimiters;
1346
1347     if (delimiter == '?') {
1348         delimiters = all_delimiters;
1349     } else if (delimiter == '0') {
1350         return strchr(param, '\0');
1351     } else if (delimiter == '.' && *param) {
1352         return param + 1;
1353     } else {
1354         curr_delimiters[0] = delimiter;
1355         delimiters = curr_delimiters;
1356     }
1357
1358     param += strcspn(param, delimiters);
1359     if (*param) {
1360         param++;
1361     }
1362     return param;
1363 }
1364
1365 static int cmd_parse_params(const char *data, const char *schema,
1366                             GdbCmdVariant *params, int *num_params)
1367 {
1368     int curr_param;
1369     const char *curr_schema, *curr_data;
1370
1371     *num_params = 0;
1372
1373     if (!schema) {
1374         return 0;
1375     }
1376
1377     curr_schema = schema;
1378     curr_param = 0;
1379     curr_data = data;
1380     while (curr_schema[0] && curr_schema[1] && *curr_data) {
1381         switch (curr_schema[0]) {
1382         case 'l':
1383             if (qemu_strtoul(curr_data, &curr_data, 16,
1384                              &params[curr_param].val_ul)) {
1385                 return -EINVAL;
1386             }
1387             curr_param++;
1388             curr_data = cmd_next_param(curr_data, curr_schema[1]);
1389             break;
1390         case 'L':
1391             if (qemu_strtou64(curr_data, &curr_data, 16,
1392                               (uint64_t *)&params[curr_param].val_ull)) {
1393                 return -EINVAL;
1394             }
1395             curr_param++;
1396             curr_data = cmd_next_param(curr_data, curr_schema[1]);
1397             break;
1398         case 's':
1399             params[curr_param].data = curr_data;
1400             curr_param++;
1401             curr_data = cmd_next_param(curr_data, curr_schema[1]);
1402             break;
1403         case 'o':
1404             params[curr_param].opcode = *(uint8_t *)curr_data;
1405             curr_param++;
1406             curr_data = cmd_next_param(curr_data, curr_schema[1]);
1407             break;
1408         case 't':
1409             params[curr_param].thread_id.kind =
1410                 read_thread_id(curr_data, &curr_data,
1411                                &params[curr_param].thread_id.pid,
1412                                &params[curr_param].thread_id.tid);
1413             curr_param++;
1414             curr_data = cmd_next_param(curr_data, curr_schema[1]);
1415             break;
1416         case '?':
1417             curr_data = cmd_next_param(curr_data, curr_schema[1]);
1418             break;
1419         default:
1420             return -EINVAL;
1421         }
1422         curr_schema += 2;
1423     }
1424
1425     *num_params = curr_param;
1426     return 0;
1427 }
1428
1429 typedef struct GdbCmdContext {
1430     GdbCmdVariant *params;
1431     int num_params;
1432 } GdbCmdContext;
1433
1434 typedef void (*GdbCmdHandler)(GdbCmdContext *gdb_ctx, void *user_ctx);
1435
1436 /*
1437  * cmd_startswith -> cmd is compared using startswith
1438  *
1439  *
1440  * schema definitions:
1441  * Each schema parameter entry consists of 2 chars,
1442  * the first char represents the parameter type handling
1443  * the second char represents the delimiter for the next parameter
1444  *
1445  * Currently supported schema types:
1446  * 'l' -> unsigned long (stored in .val_ul)
1447  * 'L' -> unsigned long long (stored in .val_ull)
1448  * 's' -> string (stored in .data)
1449  * 'o' -> single char (stored in .opcode)
1450  * 't' -> thread id (stored in .thread_id)
1451  * '?' -> skip according to delimiter
1452  *
1453  * Currently supported delimiters:
1454  * '?' -> Stop at any delimiter (",;:=\0")
1455  * '0' -> Stop at "\0"
1456  * '.' -> Skip 1 char unless reached "\0"
1457  * Any other value is treated as the delimiter value itself
1458  */
1459 typedef struct GdbCmdParseEntry {
1460     GdbCmdHandler handler;
1461     const char *cmd;
1462     bool cmd_startswith;
1463     const char *schema;
1464 } GdbCmdParseEntry;
1465
1466 static inline int startswith(const char *string, const char *pattern)
1467 {
1468   return !strncmp(string, pattern, strlen(pattern));
1469 }
1470
1471 static int process_string_cmd(void *user_ctx, const char *data,
1472                               const GdbCmdParseEntry *cmds, int num_cmds)
1473 {
1474     int i, schema_len, max_num_params = 0;
1475     GdbCmdContext gdb_ctx;
1476
1477     if (!cmds) {
1478         return -1;
1479     }
1480
1481     for (i = 0; i < num_cmds; i++) {
1482         const GdbCmdParseEntry *cmd = &cmds[i];
1483         g_assert(cmd->handler && cmd->cmd);
1484
1485         if ((cmd->cmd_startswith && !startswith(data, cmd->cmd)) ||
1486             (!cmd->cmd_startswith && strcmp(cmd->cmd, data))) {
1487             continue;
1488         }
1489
1490         if (cmd->schema) {
1491             schema_len = strlen(cmd->schema);
1492             if (schema_len % 2) {
1493                 return -2;
1494             }
1495
1496             max_num_params = schema_len / 2;
1497         }
1498
1499         gdb_ctx.params =
1500             (GdbCmdVariant *)alloca(sizeof(*gdb_ctx.params) * max_num_params);
1501         memset(gdb_ctx.params, 0, sizeof(*gdb_ctx.params) * max_num_params);
1502
1503         if (cmd_parse_params(&data[strlen(cmd->cmd)], cmd->schema,
1504                              gdb_ctx.params, &gdb_ctx.num_params)) {
1505             return -1;
1506         }
1507
1508         cmd->handler(&gdb_ctx, user_ctx);
1509         return 0;
1510     }
1511
1512     return -1;
1513 }
1514
1515 static void run_cmd_parser(const char *data, const GdbCmdParseEntry *cmd)
1516 {
1517     if (!data) {
1518         return;
1519     }
1520
1521     g_string_set_size(gdbserver_state.str_buf, 0);
1522     g_byte_array_set_size(gdbserver_state.mem_buf, 0);
1523
1524     /* In case there was an error during the command parsing we must
1525     * send a NULL packet to indicate the command is not supported */
1526     if (process_string_cmd(NULL, data, cmd, 1)) {
1527         put_packet("");
1528     }
1529 }
1530
1531 static void handle_detach(GdbCmdContext *gdb_ctx, void *user_ctx)
1532 {
1533     GDBProcess *process;
1534     uint32_t pid = 1;
1535
1536     if (gdbserver_state.multiprocess) {
1537         if (!gdb_ctx->num_params) {
1538             put_packet("E22");
1539             return;
1540         }
1541
1542         pid = gdb_ctx->params[0].val_ul;
1543     }
1544
1545     process = gdb_get_process(pid);
1546     gdb_process_breakpoint_remove_all(process);
1547     process->attached = false;
1548
1549     if (pid == gdb_get_cpu_pid(gdbserver_state.c_cpu)) {
1550         gdbserver_state.c_cpu = gdb_first_attached_cpu();
1551     }
1552
1553     if (pid == gdb_get_cpu_pid(gdbserver_state.g_cpu)) {
1554         gdbserver_state.g_cpu = gdb_first_attached_cpu();
1555     }
1556
1557     if (!gdbserver_state.c_cpu) {
1558         /* No more process attached */
1559         gdb_syscall_mode = GDB_SYS_DISABLED;
1560         gdb_continue();
1561     }
1562     put_packet("OK");
1563 }
1564
1565 static void handle_thread_alive(GdbCmdContext *gdb_ctx, void *user_ctx)
1566 {
1567     CPUState *cpu;
1568
1569     if (!gdb_ctx->num_params) {
1570         put_packet("E22");
1571         return;
1572     }
1573
1574     if (gdb_ctx->params[0].thread_id.kind == GDB_READ_THREAD_ERR) {
1575         put_packet("E22");
1576         return;
1577     }
1578
1579     cpu = gdb_get_cpu(gdb_ctx->params[0].thread_id.pid,
1580                       gdb_ctx->params[0].thread_id.tid);
1581     if (!cpu) {
1582         put_packet("E22");
1583         return;
1584     }
1585
1586     put_packet("OK");
1587 }
1588
1589 static void handle_continue(GdbCmdContext *gdb_ctx, void *user_ctx)
1590 {
1591     if (gdb_ctx->num_params) {
1592         gdb_set_cpu_pc(gdb_ctx->params[0].val_ull);
1593     }
1594
1595     gdbserver_state.signal = 0;
1596     gdb_continue();
1597 }
1598
1599 static void handle_cont_with_sig(GdbCmdContext *gdb_ctx, void *user_ctx)
1600 {
1601     unsigned long signal = 0;
1602
1603     /*
1604      * Note: C sig;[addr] is currently unsupported and we simply
1605      *       omit the addr parameter
1606      */
1607     if (gdb_ctx->num_params) {
1608         signal = gdb_ctx->params[0].val_ul;
1609     }
1610
1611     gdbserver_state.signal = gdb_signal_to_target(signal);
1612     if (gdbserver_state.signal == -1) {
1613         gdbserver_state.signal = 0;
1614     }
1615     gdb_continue();
1616 }
1617
1618 static void handle_set_thread(GdbCmdContext *gdb_ctx, void *user_ctx)
1619 {
1620     CPUState *cpu;
1621
1622     if (gdb_ctx->num_params != 2) {
1623         put_packet("E22");
1624         return;
1625     }
1626
1627     if (gdb_ctx->params[1].thread_id.kind == GDB_READ_THREAD_ERR) {
1628         put_packet("E22");
1629         return;
1630     }
1631
1632     if (gdb_ctx->params[1].thread_id.kind != GDB_ONE_THREAD) {
1633         put_packet("OK");
1634         return;
1635     }
1636
1637     cpu = gdb_get_cpu(gdb_ctx->params[1].thread_id.pid,
1638                       gdb_ctx->params[1].thread_id.tid);
1639     if (!cpu) {
1640         put_packet("E22");
1641         return;
1642     }
1643
1644     /*
1645      * Note: This command is deprecated and modern gdb's will be using the
1646      *       vCont command instead.
1647      */
1648     switch (gdb_ctx->params[0].opcode) {
1649     case 'c':
1650         gdbserver_state.c_cpu = cpu;
1651         put_packet("OK");
1652         break;
1653     case 'g':
1654         gdbserver_state.g_cpu = cpu;
1655         put_packet("OK");
1656         break;
1657     default:
1658         put_packet("E22");
1659         break;
1660     }
1661 }
1662
1663 static void handle_insert_bp(GdbCmdContext *gdb_ctx, void *user_ctx)
1664 {
1665     int res;
1666
1667     if (gdb_ctx->num_params != 3) {
1668         put_packet("E22");
1669         return;
1670     }
1671
1672     res = gdb_breakpoint_insert(gdb_ctx->params[0].val_ul,
1673                                 gdb_ctx->params[1].val_ull,
1674                                 gdb_ctx->params[2].val_ull);
1675     if (res >= 0) {
1676         put_packet("OK");
1677         return;
1678     } else if (res == -ENOSYS) {
1679         put_packet("");
1680         return;
1681     }
1682
1683     put_packet("E22");
1684 }
1685
1686 static void handle_remove_bp(GdbCmdContext *gdb_ctx, void *user_ctx)
1687 {
1688     int res;
1689
1690     if (gdb_ctx->num_params != 3) {
1691         put_packet("E22");
1692         return;
1693     }
1694
1695     res = gdb_breakpoint_remove(gdb_ctx->params[0].val_ul,
1696                                 gdb_ctx->params[1].val_ull,
1697                                 gdb_ctx->params[2].val_ull);
1698     if (res >= 0) {
1699         put_packet("OK");
1700         return;
1701     } else if (res == -ENOSYS) {
1702         put_packet("");
1703         return;
1704     }
1705
1706     put_packet("E22");
1707 }
1708
1709 /*
1710  * handle_set/get_reg
1711  *
1712  * Older gdb are really dumb, and don't use 'G/g' if 'P/p' is available.
1713  * This works, but can be very slow. Anything new enough to understand
1714  * XML also knows how to use this properly. However to use this we
1715  * need to define a local XML file as well as be talking to a
1716  * reasonably modern gdb. Responding with an empty packet will cause
1717  * the remote gdb to fallback to older methods.
1718  */
1719
1720 static void handle_set_reg(GdbCmdContext *gdb_ctx, void *user_ctx)
1721 {
1722     int reg_size;
1723
1724     if (!gdb_has_xml) {
1725         put_packet("");
1726         return;
1727     }
1728
1729     if (gdb_ctx->num_params != 2) {
1730         put_packet("E22");
1731         return;
1732     }
1733
1734     reg_size = strlen(gdb_ctx->params[1].data) / 2;
1735     hextomem(gdbserver_state.mem_buf, gdb_ctx->params[1].data, reg_size);
1736     gdb_write_register(gdbserver_state.g_cpu, gdbserver_state.mem_buf->data,
1737                        gdb_ctx->params[0].val_ull);
1738     put_packet("OK");
1739 }
1740
1741 static void handle_get_reg(GdbCmdContext *gdb_ctx, void *user_ctx)
1742 {
1743     int reg_size;
1744
1745     if (!gdb_has_xml) {
1746         put_packet("");
1747         return;
1748     }
1749
1750     if (!gdb_ctx->num_params) {
1751         put_packet("E14");
1752         return;
1753     }
1754
1755     reg_size = gdb_read_register(gdbserver_state.g_cpu,
1756                                  gdbserver_state.mem_buf,
1757                                  gdb_ctx->params[0].val_ull);
1758     if (!reg_size) {
1759         put_packet("E14");
1760         return;
1761     } else {
1762         g_byte_array_set_size(gdbserver_state.mem_buf, reg_size);
1763     }
1764
1765     memtohex(gdbserver_state.str_buf, gdbserver_state.mem_buf->data, reg_size);
1766     put_strbuf();
1767 }
1768
1769 static void handle_write_mem(GdbCmdContext *gdb_ctx, void *user_ctx)
1770 {
1771     if (gdb_ctx->num_params != 3) {
1772         put_packet("E22");
1773         return;
1774     }
1775
1776     /* hextomem() reads 2*len bytes */
1777     if (gdb_ctx->params[1].val_ull > strlen(gdb_ctx->params[2].data) / 2) {
1778         put_packet("E22");
1779         return;
1780     }
1781
1782     hextomem(gdbserver_state.mem_buf, gdb_ctx->params[2].data,
1783              gdb_ctx->params[1].val_ull);
1784     if (target_memory_rw_debug(gdbserver_state.g_cpu, gdb_ctx->params[0].val_ull,
1785                                gdbserver_state.mem_buf->data,
1786                                gdbserver_state.mem_buf->len, true)) {
1787         put_packet("E14");
1788         return;
1789     }
1790
1791     put_packet("OK");
1792 }
1793
1794 static void handle_read_mem(GdbCmdContext *gdb_ctx, void *user_ctx)
1795 {
1796     if (gdb_ctx->num_params != 2) {
1797         put_packet("E22");
1798         return;
1799     }
1800
1801     /* memtohex() doubles the required space */
1802     if (gdb_ctx->params[1].val_ull > MAX_PACKET_LENGTH / 2) {
1803         put_packet("E22");
1804         return;
1805     }
1806
1807     g_byte_array_set_size(gdbserver_state.mem_buf, gdb_ctx->params[1].val_ull);
1808
1809     if (target_memory_rw_debug(gdbserver_state.g_cpu, gdb_ctx->params[0].val_ull,
1810                                gdbserver_state.mem_buf->data,
1811                                gdbserver_state.mem_buf->len, false)) {
1812         put_packet("E14");
1813         return;
1814     }
1815
1816     memtohex(gdbserver_state.str_buf, gdbserver_state.mem_buf->data,
1817              gdbserver_state.mem_buf->len);
1818     put_strbuf();
1819 }
1820
1821 static void handle_write_all_regs(GdbCmdContext *gdb_ctx, void *user_ctx)
1822 {
1823     target_ulong addr, len;
1824     uint8_t *registers;
1825     int reg_size;
1826
1827     if (!gdb_ctx->num_params) {
1828         return;
1829     }
1830
1831     cpu_synchronize_state(gdbserver_state.g_cpu);
1832     len = strlen(gdb_ctx->params[0].data) / 2;
1833     hextomem(gdbserver_state.mem_buf, gdb_ctx->params[0].data, len);
1834     registers = gdbserver_state.mem_buf->data;
1835     for (addr = 0; addr < gdbserver_state.g_cpu->gdb_num_g_regs && len > 0;
1836          addr++) {
1837         reg_size = gdb_write_register(gdbserver_state.g_cpu, registers, addr);
1838         len -= reg_size;
1839         registers += reg_size;
1840     }
1841     put_packet("OK");
1842 }
1843
1844 static void handle_read_all_regs(GdbCmdContext *gdb_ctx, void *user_ctx)
1845 {
1846     target_ulong addr, len;
1847
1848     cpu_synchronize_state(gdbserver_state.g_cpu);
1849     g_byte_array_set_size(gdbserver_state.mem_buf, 0);
1850     len = 0;
1851     for (addr = 0; addr < gdbserver_state.g_cpu->gdb_num_g_regs; addr++) {
1852         len += gdb_read_register(gdbserver_state.g_cpu,
1853                                  gdbserver_state.mem_buf,
1854                                  addr);
1855     }
1856     g_assert(len == gdbserver_state.mem_buf->len);
1857
1858     memtohex(gdbserver_state.str_buf, gdbserver_state.mem_buf->data, len);
1859     put_strbuf();
1860 }
1861
1862 static void handle_file_io(GdbCmdContext *gdb_ctx, void *user_ctx)
1863 {
1864     if (gdb_ctx->num_params >= 1 && gdbserver_state.current_syscall_cb) {
1865         target_ulong ret, err;
1866
1867         ret = (target_ulong)gdb_ctx->params[0].val_ull;
1868         if (gdb_ctx->num_params >= 2) {
1869             err = (target_ulong)gdb_ctx->params[1].val_ull;
1870         } else {
1871             err = 0;
1872         }
1873         gdbserver_state.current_syscall_cb(gdbserver_state.c_cpu, ret, err);
1874         gdbserver_state.current_syscall_cb = NULL;
1875     }
1876
1877     if (gdb_ctx->num_params >= 3 && gdb_ctx->params[2].opcode == (uint8_t)'C') {
1878         put_packet("T02");
1879         return;
1880     }
1881
1882     gdb_continue();
1883 }
1884
1885 static void handle_step(GdbCmdContext *gdb_ctx, void *user_ctx)
1886 {
1887     if (gdb_ctx->num_params) {
1888         gdb_set_cpu_pc((target_ulong)gdb_ctx->params[0].val_ull);
1889     }
1890
1891     cpu_single_step(gdbserver_state.c_cpu, get_sstep_flags());
1892     gdb_continue();
1893 }
1894
1895 static void handle_backward(GdbCmdContext *gdb_ctx, void *user_ctx)
1896 {
1897     if (replay_mode != REPLAY_MODE_PLAY) {
1898         put_packet("E22");
1899     }
1900     if (gdb_ctx->num_params == 1) {
1901         switch (gdb_ctx->params[0].opcode) {
1902         case 's':
1903             if (replay_reverse_step()) {
1904                 gdb_continue();
1905             } else {
1906                 put_packet("E14");
1907             }
1908             return;
1909         case 'c':
1910             if (replay_reverse_continue()) {
1911                 gdb_continue();
1912             } else {
1913                 put_packet("E14");
1914             }
1915             return;
1916         }
1917     }
1918
1919     /* Default invalid command */
1920     put_packet("");
1921 }
1922
1923 static void handle_v_cont_query(GdbCmdContext *gdb_ctx, void *user_ctx)
1924 {
1925     put_packet("vCont;c;C;s;S");
1926 }
1927
1928 static void handle_v_cont(GdbCmdContext *gdb_ctx, void *user_ctx)
1929 {
1930     int res;
1931
1932     if (!gdb_ctx->num_params) {
1933         return;
1934     }
1935
1936     res = gdb_handle_vcont(gdb_ctx->params[0].data);
1937     if ((res == -EINVAL) || (res == -ERANGE)) {
1938         put_packet("E22");
1939     } else if (res) {
1940         put_packet("");
1941     }
1942 }
1943
1944 static void handle_v_attach(GdbCmdContext *gdb_ctx, void *user_ctx)
1945 {
1946     GDBProcess *process;
1947     CPUState *cpu;
1948
1949     g_string_assign(gdbserver_state.str_buf, "E22");
1950     if (!gdb_ctx->num_params) {
1951         goto cleanup;
1952     }
1953
1954     process = gdb_get_process(gdb_ctx->params[0].val_ul);
1955     if (!process) {
1956         goto cleanup;
1957     }
1958
1959     cpu = get_first_cpu_in_process(process);
1960     if (!cpu) {
1961         goto cleanup;
1962     }
1963
1964     process->attached = true;
1965     gdbserver_state.g_cpu = cpu;
1966     gdbserver_state.c_cpu = cpu;
1967
1968     g_string_printf(gdbserver_state.str_buf, "T%02xthread:", GDB_SIGNAL_TRAP);
1969     gdb_append_thread_id(cpu, gdbserver_state.str_buf);
1970     g_string_append_c(gdbserver_state.str_buf, ';');
1971 cleanup:
1972     put_strbuf();
1973 }
1974
1975 static void handle_v_kill(GdbCmdContext *gdb_ctx, void *user_ctx)
1976 {
1977     /* Kill the target */
1978     put_packet("OK");
1979     error_report("QEMU: Terminated via GDBstub");
1980     gdb_exit(0);
1981     exit(0);
1982 }
1983
1984 static GdbCmdParseEntry gdb_v_commands_table[] = {
1985     /* Order is important if has same prefix */
1986     {
1987         .handler = handle_v_cont_query,
1988         .cmd = "Cont?",
1989         .cmd_startswith = 1
1990     },
1991     {
1992         .handler = handle_v_cont,
1993         .cmd = "Cont",
1994         .cmd_startswith = 1,
1995         .schema = "s0"
1996     },
1997     {
1998         .handler = handle_v_attach,
1999         .cmd = "Attach;",
2000         .cmd_startswith = 1,
2001         .schema = "l0"
2002     },
2003     {
2004         .handler = handle_v_kill,
2005         .cmd = "Kill;",
2006         .cmd_startswith = 1
2007     },
2008 };
2009
2010 static void handle_v_commands(GdbCmdContext *gdb_ctx, void *user_ctx)
2011 {
2012     if (!gdb_ctx->num_params) {
2013         return;
2014     }
2015
2016     if (process_string_cmd(NULL, gdb_ctx->params[0].data,
2017                            gdb_v_commands_table,
2018                            ARRAY_SIZE(gdb_v_commands_table))) {
2019         put_packet("");
2020     }
2021 }
2022
2023 static void handle_query_qemu_sstepbits(GdbCmdContext *gdb_ctx, void *user_ctx)
2024 {
2025     g_string_printf(gdbserver_state.str_buf, "ENABLE=%x,NOIRQ=%x,NOTIMER=%x",
2026                     SSTEP_ENABLE, SSTEP_NOIRQ, SSTEP_NOTIMER);
2027     put_strbuf();
2028 }
2029
2030 static void handle_set_qemu_sstep(GdbCmdContext *gdb_ctx, void *user_ctx)
2031 {
2032     if (!gdb_ctx->num_params) {
2033         return;
2034     }
2035
2036     sstep_flags = gdb_ctx->params[0].val_ul;
2037     put_packet("OK");
2038 }
2039
2040 static void handle_query_qemu_sstep(GdbCmdContext *gdb_ctx, void *user_ctx)
2041 {
2042     g_string_printf(gdbserver_state.str_buf, "0x%x", sstep_flags);
2043     put_strbuf();
2044 }
2045
2046 static void handle_query_curr_tid(GdbCmdContext *gdb_ctx, void *user_ctx)
2047 {
2048     CPUState *cpu;
2049     GDBProcess *process;
2050
2051     /*
2052      * "Current thread" remains vague in the spec, so always return
2053      * the first thread of the current process (gdb returns the
2054      * first thread).
2055      */
2056     process = gdb_get_cpu_process(gdbserver_state.g_cpu);
2057     cpu = get_first_cpu_in_process(process);
2058     g_string_assign(gdbserver_state.str_buf, "QC");
2059     gdb_append_thread_id(cpu, gdbserver_state.str_buf);
2060     put_strbuf();
2061 }
2062
2063 static void handle_query_threads(GdbCmdContext *gdb_ctx, void *user_ctx)
2064 {
2065     if (!gdbserver_state.query_cpu) {
2066         put_packet("l");
2067         return;
2068     }
2069
2070     g_string_assign(gdbserver_state.str_buf, "m");
2071     gdb_append_thread_id(gdbserver_state.query_cpu, gdbserver_state.str_buf);
2072     put_strbuf();
2073     gdbserver_state.query_cpu = gdb_next_attached_cpu(gdbserver_state.query_cpu);
2074 }
2075
2076 static void handle_query_first_threads(GdbCmdContext *gdb_ctx, void *user_ctx)
2077 {
2078     gdbserver_state.query_cpu = gdb_first_attached_cpu();
2079     handle_query_threads(gdb_ctx, user_ctx);
2080 }
2081
2082 static void handle_query_thread_extra(GdbCmdContext *gdb_ctx, void *user_ctx)
2083 {
2084     g_autoptr(GString) rs = g_string_new(NULL);
2085     CPUState *cpu;
2086
2087     if (!gdb_ctx->num_params ||
2088         gdb_ctx->params[0].thread_id.kind == GDB_READ_THREAD_ERR) {
2089         put_packet("E22");
2090         return;
2091     }
2092
2093     cpu = gdb_get_cpu(gdb_ctx->params[0].thread_id.pid,
2094                       gdb_ctx->params[0].thread_id.tid);
2095     if (!cpu) {
2096         return;
2097     }
2098
2099     cpu_synchronize_state(cpu);
2100
2101     if (gdbserver_state.multiprocess && (gdbserver_state.process_num > 1)) {
2102         /* Print the CPU model and name in multiprocess mode */
2103         ObjectClass *oc = object_get_class(OBJECT(cpu));
2104         const char *cpu_model = object_class_get_name(oc);
2105         const char *cpu_name =
2106             object_get_canonical_path_component(OBJECT(cpu));
2107         g_string_printf(rs, "%s %s [%s]", cpu_model, cpu_name,
2108                         cpu->halted ? "halted " : "running");
2109     } else {
2110         g_string_printf(rs, "CPU#%d [%s]", cpu->cpu_index,
2111                         cpu->halted ? "halted " : "running");
2112     }
2113     trace_gdbstub_op_extra_info(rs->str);
2114     memtohex(gdbserver_state.str_buf, (uint8_t *)rs->str, rs->len);
2115     put_strbuf();
2116 }
2117
2118 #ifdef CONFIG_USER_ONLY
2119 static void handle_query_offsets(GdbCmdContext *gdb_ctx, void *user_ctx)
2120 {
2121     TaskState *ts;
2122
2123     ts = gdbserver_state.c_cpu->opaque;
2124     g_string_printf(gdbserver_state.str_buf,
2125                     "Text=" TARGET_ABI_FMT_lx
2126                     ";Data=" TARGET_ABI_FMT_lx
2127                     ";Bss=" TARGET_ABI_FMT_lx,
2128                     ts->info->code_offset,
2129                     ts->info->data_offset,
2130                     ts->info->data_offset);
2131     put_strbuf();
2132 }
2133 #else
2134 static void handle_query_rcmd(GdbCmdContext *gdb_ctx, void *user_ctx)
2135 {
2136     const guint8 zero = 0;
2137     int len;
2138
2139     if (!gdb_ctx->num_params) {
2140         put_packet("E22");
2141         return;
2142     }
2143
2144     len = strlen(gdb_ctx->params[0].data);
2145     if (len % 2) {
2146         put_packet("E01");
2147         return;
2148     }
2149
2150     g_assert(gdbserver_state.mem_buf->len == 0);
2151     len = len / 2;
2152     hextomem(gdbserver_state.mem_buf, gdb_ctx->params[0].data, len);
2153     g_byte_array_append(gdbserver_state.mem_buf, &zero, 1);
2154     qemu_chr_be_write(gdbserver_state.mon_chr, gdbserver_state.mem_buf->data,
2155                       gdbserver_state.mem_buf->len);
2156     put_packet("OK");
2157 }
2158 #endif
2159
2160 static void handle_query_supported(GdbCmdContext *gdb_ctx, void *user_ctx)
2161 {
2162     CPUClass *cc;
2163
2164     g_string_printf(gdbserver_state.str_buf, "PacketSize=%x", MAX_PACKET_LENGTH);
2165     cc = CPU_GET_CLASS(first_cpu);
2166     if (cc->gdb_core_xml_file) {
2167         g_string_append(gdbserver_state.str_buf, ";qXfer:features:read+");
2168     }
2169
2170     if (replay_mode == REPLAY_MODE_PLAY) {
2171         g_string_append(gdbserver_state.str_buf,
2172             ";ReverseStep+;ReverseContinue+");
2173     }
2174
2175 #ifdef CONFIG_USER_ONLY
2176     if (gdbserver_state.c_cpu->opaque) {
2177         g_string_append(gdbserver_state.str_buf, ";qXfer:auxv:read+");
2178     }
2179 #endif
2180
2181     if (gdb_ctx->num_params &&
2182         strstr(gdb_ctx->params[0].data, "multiprocess+")) {
2183         gdbserver_state.multiprocess = true;
2184     }
2185
2186     g_string_append(gdbserver_state.str_buf, ";vContSupported+;multiprocess+");
2187     put_strbuf();
2188 }
2189
2190 static void handle_query_xfer_features(GdbCmdContext *gdb_ctx, void *user_ctx)
2191 {
2192     GDBProcess *process;
2193     CPUClass *cc;
2194     unsigned long len, total_len, addr;
2195     const char *xml;
2196     const char *p;
2197
2198     if (gdb_ctx->num_params < 3) {
2199         put_packet("E22");
2200         return;
2201     }
2202
2203     process = gdb_get_cpu_process(gdbserver_state.g_cpu);
2204     cc = CPU_GET_CLASS(gdbserver_state.g_cpu);
2205     if (!cc->gdb_core_xml_file) {
2206         put_packet("");
2207         return;
2208     }
2209
2210     gdb_has_xml = true;
2211     p = gdb_ctx->params[0].data;
2212     xml = get_feature_xml(p, &p, process);
2213     if (!xml) {
2214         put_packet("E00");
2215         return;
2216     }
2217
2218     addr = gdb_ctx->params[1].val_ul;
2219     len = gdb_ctx->params[2].val_ul;
2220     total_len = strlen(xml);
2221     if (addr > total_len) {
2222         put_packet("E00");
2223         return;
2224     }
2225
2226     if (len > (MAX_PACKET_LENGTH - 5) / 2) {
2227         len = (MAX_PACKET_LENGTH - 5) / 2;
2228     }
2229
2230     if (len < total_len - addr) {
2231         g_string_assign(gdbserver_state.str_buf, "m");
2232         memtox(gdbserver_state.str_buf, xml + addr, len);
2233     } else {
2234         g_string_assign(gdbserver_state.str_buf, "l");
2235         memtox(gdbserver_state.str_buf, xml + addr, total_len - addr);
2236     }
2237
2238     put_packet_binary(gdbserver_state.str_buf->str,
2239                       gdbserver_state.str_buf->len, true);
2240 }
2241
2242 #if defined(CONFIG_USER_ONLY) && defined(CONFIG_LINUX_USER)
2243 static void handle_query_xfer_auxv(GdbCmdContext *gdb_ctx, void *user_ctx)
2244 {
2245     TaskState *ts;
2246     unsigned long offset, len, saved_auxv, auxv_len;
2247
2248     if (gdb_ctx->num_params < 2) {
2249         put_packet("E22");
2250         return;
2251     }
2252
2253     offset = gdb_ctx->params[0].val_ul;
2254     len = gdb_ctx->params[1].val_ul;
2255     ts = gdbserver_state.c_cpu->opaque;
2256     saved_auxv = ts->info->saved_auxv;
2257     auxv_len = ts->info->auxv_len;
2258
2259     if (offset >= auxv_len) {
2260         put_packet("E00");
2261         return;
2262     }
2263
2264     if (len > (MAX_PACKET_LENGTH - 5) / 2) {
2265         len = (MAX_PACKET_LENGTH - 5) / 2;
2266     }
2267
2268     if (len < auxv_len - offset) {
2269         g_string_assign(gdbserver_state.str_buf, "m");
2270     } else {
2271         g_string_assign(gdbserver_state.str_buf, "l");
2272         len = auxv_len - offset;
2273     }
2274
2275     g_byte_array_set_size(gdbserver_state.mem_buf, len);
2276     if (target_memory_rw_debug(gdbserver_state.g_cpu, saved_auxv + offset,
2277                                gdbserver_state.mem_buf->data, len, false)) {
2278         put_packet("E14");
2279         return;
2280     }
2281
2282     memtox(gdbserver_state.str_buf,
2283            (const char *)gdbserver_state.mem_buf->data, len);
2284     put_packet_binary(gdbserver_state.str_buf->str,
2285                       gdbserver_state.str_buf->len, true);
2286 }
2287 #endif
2288
2289 static void handle_query_attached(GdbCmdContext *gdb_ctx, void *user_ctx)
2290 {
2291     put_packet(GDB_ATTACHED);
2292 }
2293
2294 static void handle_query_qemu_supported(GdbCmdContext *gdb_ctx, void *user_ctx)
2295 {
2296     g_string_printf(gdbserver_state.str_buf, "sstepbits;sstep");
2297 #ifndef CONFIG_USER_ONLY
2298     g_string_append(gdbserver_state.str_buf, ";PhyMemMode");
2299 #endif
2300     put_strbuf();
2301 }
2302
2303 #ifndef CONFIG_USER_ONLY
2304 static void handle_query_qemu_phy_mem_mode(GdbCmdContext *gdb_ctx,
2305                                            void *user_ctx)
2306 {
2307     g_string_printf(gdbserver_state.str_buf, "%d", phy_memory_mode);
2308     put_strbuf();
2309 }
2310
2311 static void handle_set_qemu_phy_mem_mode(GdbCmdContext *gdb_ctx, void *user_ctx)
2312 {
2313     if (!gdb_ctx->num_params) {
2314         put_packet("E22");
2315         return;
2316     }
2317
2318     if (!gdb_ctx->params[0].val_ul) {
2319         phy_memory_mode = 0;
2320     } else {
2321         phy_memory_mode = 1;
2322     }
2323     put_packet("OK");
2324 }
2325 #endif
2326
2327 static GdbCmdParseEntry gdb_gen_query_set_common_table[] = {
2328     /* Order is important if has same prefix */
2329     {
2330         .handler = handle_query_qemu_sstepbits,
2331         .cmd = "qemu.sstepbits",
2332     },
2333     {
2334         .handler = handle_query_qemu_sstep,
2335         .cmd = "qemu.sstep",
2336     },
2337     {
2338         .handler = handle_set_qemu_sstep,
2339         .cmd = "qemu.sstep=",
2340         .cmd_startswith = 1,
2341         .schema = "l0"
2342     },
2343 };
2344
2345 static GdbCmdParseEntry gdb_gen_query_table[] = {
2346     {
2347         .handler = handle_query_curr_tid,
2348         .cmd = "C",
2349     },
2350     {
2351         .handler = handle_query_threads,
2352         .cmd = "sThreadInfo",
2353     },
2354     {
2355         .handler = handle_query_first_threads,
2356         .cmd = "fThreadInfo",
2357     },
2358     {
2359         .handler = handle_query_thread_extra,
2360         .cmd = "ThreadExtraInfo,",
2361         .cmd_startswith = 1,
2362         .schema = "t0"
2363     },
2364 #ifdef CONFIG_USER_ONLY
2365     {
2366         .handler = handle_query_offsets,
2367         .cmd = "Offsets",
2368     },
2369 #else
2370     {
2371         .handler = handle_query_rcmd,
2372         .cmd = "Rcmd,",
2373         .cmd_startswith = 1,
2374         .schema = "s0"
2375     },
2376 #endif
2377     {
2378         .handler = handle_query_supported,
2379         .cmd = "Supported:",
2380         .cmd_startswith = 1,
2381         .schema = "s0"
2382     },
2383     {
2384         .handler = handle_query_supported,
2385         .cmd = "Supported",
2386         .schema = "s0"
2387     },
2388     {
2389         .handler = handle_query_xfer_features,
2390         .cmd = "Xfer:features:read:",
2391         .cmd_startswith = 1,
2392         .schema = "s:l,l0"
2393     },
2394 #if defined(CONFIG_USER_ONLY) && defined(CONFIG_LINUX_USER)
2395     {
2396         .handler = handle_query_xfer_auxv,
2397         .cmd = "Xfer:auxv:read::",
2398         .cmd_startswith = 1,
2399         .schema = "l,l0"
2400     },
2401 #endif
2402     {
2403         .handler = handle_query_attached,
2404         .cmd = "Attached:",
2405         .cmd_startswith = 1
2406     },
2407     {
2408         .handler = handle_query_attached,
2409         .cmd = "Attached",
2410     },
2411     {
2412         .handler = handle_query_qemu_supported,
2413         .cmd = "qemu.Supported",
2414     },
2415 #ifndef CONFIG_USER_ONLY
2416     {
2417         .handler = handle_query_qemu_phy_mem_mode,
2418         .cmd = "qemu.PhyMemMode",
2419     },
2420 #endif
2421 };
2422
2423 static GdbCmdParseEntry gdb_gen_set_table[] = {
2424     /* Order is important if has same prefix */
2425     {
2426         .handler = handle_set_qemu_sstep,
2427         .cmd = "qemu.sstep:",
2428         .cmd_startswith = 1,
2429         .schema = "l0"
2430     },
2431 #ifndef CONFIG_USER_ONLY
2432     {
2433         .handler = handle_set_qemu_phy_mem_mode,
2434         .cmd = "qemu.PhyMemMode:",
2435         .cmd_startswith = 1,
2436         .schema = "l0"
2437     },
2438 #endif
2439 };
2440
2441 static void handle_gen_query(GdbCmdContext *gdb_ctx, void *user_ctx)
2442 {
2443     if (!gdb_ctx->num_params) {
2444         return;
2445     }
2446
2447     if (!process_string_cmd(NULL, gdb_ctx->params[0].data,
2448                             gdb_gen_query_set_common_table,
2449                             ARRAY_SIZE(gdb_gen_query_set_common_table))) {
2450         return;
2451     }
2452
2453     if (process_string_cmd(NULL, gdb_ctx->params[0].data,
2454                            gdb_gen_query_table,
2455                            ARRAY_SIZE(gdb_gen_query_table))) {
2456         put_packet("");
2457     }
2458 }
2459
2460 static void handle_gen_set(GdbCmdContext *gdb_ctx, void *user_ctx)
2461 {
2462     if (!gdb_ctx->num_params) {
2463         return;
2464     }
2465
2466     if (!process_string_cmd(NULL, gdb_ctx->params[0].data,
2467                             gdb_gen_query_set_common_table,
2468                             ARRAY_SIZE(gdb_gen_query_set_common_table))) {
2469         return;
2470     }
2471
2472     if (process_string_cmd(NULL, gdb_ctx->params[0].data,
2473                            gdb_gen_set_table,
2474                            ARRAY_SIZE(gdb_gen_set_table))) {
2475         put_packet("");
2476     }
2477 }
2478
2479 static void handle_target_halt(GdbCmdContext *gdb_ctx, void *user_ctx)
2480 {
2481     g_string_printf(gdbserver_state.str_buf, "T%02xthread:", GDB_SIGNAL_TRAP);
2482     gdb_append_thread_id(gdbserver_state.c_cpu, gdbserver_state.str_buf);
2483     g_string_append_c(gdbserver_state.str_buf, ';');
2484     put_strbuf();
2485     /*
2486      * Remove all the breakpoints when this query is issued,
2487      * because gdb is doing an initial connect and the state
2488      * should be cleaned up.
2489      */
2490     gdb_breakpoint_remove_all();
2491 }
2492
2493 static int gdb_handle_packet(const char *line_buf)
2494 {
2495     const GdbCmdParseEntry *cmd_parser = NULL;
2496
2497     trace_gdbstub_io_command(line_buf);
2498
2499     switch (line_buf[0]) {
2500     case '!':
2501         put_packet("OK");
2502         break;
2503     case '?':
2504         {
2505             static const GdbCmdParseEntry target_halted_cmd_desc = {
2506                 .handler = handle_target_halt,
2507                 .cmd = "?",
2508                 .cmd_startswith = 1
2509             };
2510             cmd_parser = &target_halted_cmd_desc;
2511         }
2512         break;
2513     case 'c':
2514         {
2515             static const GdbCmdParseEntry continue_cmd_desc = {
2516                 .handler = handle_continue,
2517                 .cmd = "c",
2518                 .cmd_startswith = 1,
2519                 .schema = "L0"
2520             };
2521             cmd_parser = &continue_cmd_desc;
2522         }
2523         break;
2524     case 'C':
2525         {
2526             static const GdbCmdParseEntry cont_with_sig_cmd_desc = {
2527                 .handler = handle_cont_with_sig,
2528                 .cmd = "C",
2529                 .cmd_startswith = 1,
2530                 .schema = "l0"
2531             };
2532             cmd_parser = &cont_with_sig_cmd_desc;
2533         }
2534         break;
2535     case 'v':
2536         {
2537             static const GdbCmdParseEntry v_cmd_desc = {
2538                 .handler = handle_v_commands,
2539                 .cmd = "v",
2540                 .cmd_startswith = 1,
2541                 .schema = "s0"
2542             };
2543             cmd_parser = &v_cmd_desc;
2544         }
2545         break;
2546     case 'k':
2547         /* Kill the target */
2548         error_report("QEMU: Terminated via GDBstub");
2549         gdb_exit(0);
2550         exit(0);
2551     case 'D':
2552         {
2553             static const GdbCmdParseEntry detach_cmd_desc = {
2554                 .handler = handle_detach,
2555                 .cmd = "D",
2556                 .cmd_startswith = 1,
2557                 .schema = "?.l0"
2558             };
2559             cmd_parser = &detach_cmd_desc;
2560         }
2561         break;
2562     case 's':
2563         {
2564             static const GdbCmdParseEntry step_cmd_desc = {
2565                 .handler = handle_step,
2566                 .cmd = "s",
2567                 .cmd_startswith = 1,
2568                 .schema = "L0"
2569             };
2570             cmd_parser = &step_cmd_desc;
2571         }
2572         break;
2573     case 'b':
2574         {
2575             static const GdbCmdParseEntry backward_cmd_desc = {
2576                 .handler = handle_backward,
2577                 .cmd = "b",
2578                 .cmd_startswith = 1,
2579                 .schema = "o0"
2580             };
2581             cmd_parser = &backward_cmd_desc;
2582         }
2583         break;
2584     case 'F':
2585         {
2586             static const GdbCmdParseEntry file_io_cmd_desc = {
2587                 .handler = handle_file_io,
2588                 .cmd = "F",
2589                 .cmd_startswith = 1,
2590                 .schema = "L,L,o0"
2591             };
2592             cmd_parser = &file_io_cmd_desc;
2593         }
2594         break;
2595     case 'g':
2596         {
2597             static const GdbCmdParseEntry read_all_regs_cmd_desc = {
2598                 .handler = handle_read_all_regs,
2599                 .cmd = "g",
2600                 .cmd_startswith = 1
2601             };
2602             cmd_parser = &read_all_regs_cmd_desc;
2603         }
2604         break;
2605     case 'G':
2606         {
2607             static const GdbCmdParseEntry write_all_regs_cmd_desc = {
2608                 .handler = handle_write_all_regs,
2609                 .cmd = "G",
2610                 .cmd_startswith = 1,
2611                 .schema = "s0"
2612             };
2613             cmd_parser = &write_all_regs_cmd_desc;
2614         }
2615         break;
2616     case 'm':
2617         {
2618             static const GdbCmdParseEntry read_mem_cmd_desc = {
2619                 .handler = handle_read_mem,
2620                 .cmd = "m",
2621                 .cmd_startswith = 1,
2622                 .schema = "L,L0"
2623             };
2624             cmd_parser = &read_mem_cmd_desc;
2625         }
2626         break;
2627     case 'M':
2628         {
2629             static const GdbCmdParseEntry write_mem_cmd_desc = {
2630                 .handler = handle_write_mem,
2631                 .cmd = "M",
2632                 .cmd_startswith = 1,
2633                 .schema = "L,L:s0"
2634             };
2635             cmd_parser = &write_mem_cmd_desc;
2636         }
2637         break;
2638     case 'p':
2639         {
2640             static const GdbCmdParseEntry get_reg_cmd_desc = {
2641                 .handler = handle_get_reg,
2642                 .cmd = "p",
2643                 .cmd_startswith = 1,
2644                 .schema = "L0"
2645             };
2646             cmd_parser = &get_reg_cmd_desc;
2647         }
2648         break;
2649     case 'P':
2650         {
2651             static const GdbCmdParseEntry set_reg_cmd_desc = {
2652                 .handler = handle_set_reg,
2653                 .cmd = "P",
2654                 .cmd_startswith = 1,
2655                 .schema = "L?s0"
2656             };
2657             cmd_parser = &set_reg_cmd_desc;
2658         }
2659         break;
2660     case 'Z':
2661         {
2662             static const GdbCmdParseEntry insert_bp_cmd_desc = {
2663                 .handler = handle_insert_bp,
2664                 .cmd = "Z",
2665                 .cmd_startswith = 1,
2666                 .schema = "l?L?L0"
2667             };
2668             cmd_parser = &insert_bp_cmd_desc;
2669         }
2670         break;
2671     case 'z':
2672         {
2673             static const GdbCmdParseEntry remove_bp_cmd_desc = {
2674                 .handler = handle_remove_bp,
2675                 .cmd = "z",
2676                 .cmd_startswith = 1,
2677                 .schema = "l?L?L0"
2678             };
2679             cmd_parser = &remove_bp_cmd_desc;
2680         }
2681         break;
2682     case 'H':
2683         {
2684             static const GdbCmdParseEntry set_thread_cmd_desc = {
2685                 .handler = handle_set_thread,
2686                 .cmd = "H",
2687                 .cmd_startswith = 1,
2688                 .schema = "o.t0"
2689             };
2690             cmd_parser = &set_thread_cmd_desc;
2691         }
2692         break;
2693     case 'T':
2694         {
2695             static const GdbCmdParseEntry thread_alive_cmd_desc = {
2696                 .handler = handle_thread_alive,
2697                 .cmd = "T",
2698                 .cmd_startswith = 1,
2699                 .schema = "t0"
2700             };
2701             cmd_parser = &thread_alive_cmd_desc;
2702         }
2703         break;
2704     case 'q':
2705         {
2706             static const GdbCmdParseEntry gen_query_cmd_desc = {
2707                 .handler = handle_gen_query,
2708                 .cmd = "q",
2709                 .cmd_startswith = 1,
2710                 .schema = "s0"
2711             };
2712             cmd_parser = &gen_query_cmd_desc;
2713         }
2714         break;
2715     case 'Q':
2716         {
2717             static const GdbCmdParseEntry gen_set_cmd_desc = {
2718                 .handler = handle_gen_set,
2719                 .cmd = "Q",
2720                 .cmd_startswith = 1,
2721                 .schema = "s0"
2722             };
2723             cmd_parser = &gen_set_cmd_desc;
2724         }
2725         break;
2726     default:
2727         /* put empty packet */
2728         put_packet("");
2729         break;
2730     }
2731
2732     if (cmd_parser) {
2733         run_cmd_parser(line_buf, cmd_parser);
2734     }
2735
2736     return RS_IDLE;
2737 }
2738
2739 void gdb_set_stop_cpu(CPUState *cpu)
2740 {
2741     GDBProcess *p = gdb_get_cpu_process(cpu);
2742
2743     if (!p->attached) {
2744         /*
2745          * Having a stop CPU corresponding to a process that is not attached
2746          * confuses GDB. So we ignore the request.
2747          */
2748         return;
2749     }
2750
2751     gdbserver_state.c_cpu = cpu;
2752     gdbserver_state.g_cpu = cpu;
2753 }
2754
2755 #ifndef CONFIG_USER_ONLY
2756 static void gdb_vm_state_change(void *opaque, bool running, RunState state)
2757 {
2758     CPUState *cpu = gdbserver_state.c_cpu;
2759     g_autoptr(GString) buf = g_string_new(NULL);
2760     g_autoptr(GString) tid = g_string_new(NULL);
2761     const char *type;
2762     int ret;
2763
2764     if (running || gdbserver_state.state == RS_INACTIVE) {
2765         return;
2766     }
2767     /* Is there a GDB syscall waiting to be sent?  */
2768     if (gdbserver_state.current_syscall_cb) {
2769         put_packet(gdbserver_state.syscall_buf);
2770         return;
2771     }
2772
2773     if (cpu == NULL) {
2774         /* No process attached */
2775         return;
2776     }
2777
2778     gdb_append_thread_id(cpu, tid);
2779
2780     switch (state) {
2781     case RUN_STATE_DEBUG:
2782         if (cpu->watchpoint_hit) {
2783             switch (cpu->watchpoint_hit->flags & BP_MEM_ACCESS) {
2784             case BP_MEM_READ:
2785                 type = "r";
2786                 break;
2787             case BP_MEM_ACCESS:
2788                 type = "a";
2789                 break;
2790             default:
2791                 type = "";
2792                 break;
2793             }
2794             trace_gdbstub_hit_watchpoint(type, cpu_gdb_index(cpu),
2795                     (target_ulong)cpu->watchpoint_hit->vaddr);
2796             g_string_printf(buf, "T%02xthread:%s;%swatch:" TARGET_FMT_lx ";",
2797                             GDB_SIGNAL_TRAP, tid->str, type,
2798                             (target_ulong)cpu->watchpoint_hit->vaddr);
2799             cpu->watchpoint_hit = NULL;
2800             goto send_packet;
2801         } else {
2802             trace_gdbstub_hit_break();
2803         }
2804         tb_flush(cpu);
2805         ret = GDB_SIGNAL_TRAP;
2806         break;
2807     case RUN_STATE_PAUSED:
2808         trace_gdbstub_hit_paused();
2809         ret = GDB_SIGNAL_INT;
2810         break;
2811     case RUN_STATE_SHUTDOWN:
2812         trace_gdbstub_hit_shutdown();
2813         ret = GDB_SIGNAL_QUIT;
2814         break;
2815     case RUN_STATE_IO_ERROR:
2816         trace_gdbstub_hit_io_error();
2817         ret = GDB_SIGNAL_IO;
2818         break;
2819     case RUN_STATE_WATCHDOG:
2820         trace_gdbstub_hit_watchdog();
2821         ret = GDB_SIGNAL_ALRM;
2822         break;
2823     case RUN_STATE_INTERNAL_ERROR:
2824         trace_gdbstub_hit_internal_error();
2825         ret = GDB_SIGNAL_ABRT;
2826         break;
2827     case RUN_STATE_SAVE_VM:
2828     case RUN_STATE_RESTORE_VM:
2829         return;
2830     case RUN_STATE_FINISH_MIGRATE:
2831         ret = GDB_SIGNAL_XCPU;
2832         break;
2833     default:
2834         trace_gdbstub_hit_unknown(state);
2835         ret = GDB_SIGNAL_UNKNOWN;
2836         break;
2837     }
2838     gdb_set_stop_cpu(cpu);
2839     g_string_printf(buf, "T%02xthread:%s;", ret, tid->str);
2840
2841 send_packet:
2842     put_packet(buf->str);
2843
2844     /* disable single step if it was enabled */
2845     cpu_single_step(cpu, 0);
2846 }
2847 #endif
2848
2849 /* Send a gdb syscall request.
2850    This accepts limited printf-style format specifiers, specifically:
2851     %x  - target_ulong argument printed in hex.
2852     %lx - 64-bit argument printed in hex.
2853     %s  - string pointer (target_ulong) and length (int) pair.  */
2854 void gdb_do_syscallv(gdb_syscall_complete_cb cb, const char *fmt, va_list va)
2855 {
2856     char *p;
2857     char *p_end;
2858     target_ulong addr;
2859     uint64_t i64;
2860
2861     if (!gdbserver_state.init) {
2862         return;
2863     }
2864
2865     gdbserver_state.current_syscall_cb = cb;
2866 #ifndef CONFIG_USER_ONLY
2867     vm_stop(RUN_STATE_DEBUG);
2868 #endif
2869     p = &gdbserver_state.syscall_buf[0];
2870     p_end = &gdbserver_state.syscall_buf[sizeof(gdbserver_state.syscall_buf)];
2871     *(p++) = 'F';
2872     while (*fmt) {
2873         if (*fmt == '%') {
2874             fmt++;
2875             switch (*fmt++) {
2876             case 'x':
2877                 addr = va_arg(va, target_ulong);
2878                 p += snprintf(p, p_end - p, TARGET_FMT_lx, addr);
2879                 break;
2880             case 'l':
2881                 if (*(fmt++) != 'x')
2882                     goto bad_format;
2883                 i64 = va_arg(va, uint64_t);
2884                 p += snprintf(p, p_end - p, "%" PRIx64, i64);
2885                 break;
2886             case 's':
2887                 addr = va_arg(va, target_ulong);
2888                 p += snprintf(p, p_end - p, TARGET_FMT_lx "/%x",
2889                               addr, va_arg(va, int));
2890                 break;
2891             default:
2892             bad_format:
2893                 error_report("gdbstub: Bad syscall format string '%s'",
2894                              fmt - 1);
2895                 break;
2896             }
2897         } else {
2898             *(p++) = *(fmt++);
2899         }
2900     }
2901     *p = 0;
2902 #ifdef CONFIG_USER_ONLY
2903     put_packet(gdbserver_state.syscall_buf);
2904     /* Return control to gdb for it to process the syscall request.
2905      * Since the protocol requires that gdb hands control back to us
2906      * using a "here are the results" F packet, we don't need to check
2907      * gdb_handlesig's return value (which is the signal to deliver if
2908      * execution was resumed via a continue packet).
2909      */
2910     gdb_handlesig(gdbserver_state.c_cpu, 0);
2911 #else
2912     /* In this case wait to send the syscall packet until notification that
2913        the CPU has stopped.  This must be done because if the packet is sent
2914        now the reply from the syscall request could be received while the CPU
2915        is still in the running state, which can cause packets to be dropped
2916        and state transition 'T' packets to be sent while the syscall is still
2917        being processed.  */
2918     qemu_cpu_kick(gdbserver_state.c_cpu);
2919 #endif
2920 }
2921
2922 void gdb_do_syscall(gdb_syscall_complete_cb cb, const char *fmt, ...)
2923 {
2924     va_list va;
2925
2926     va_start(va, fmt);
2927     gdb_do_syscallv(cb, fmt, va);
2928     va_end(va);
2929 }
2930
2931 static void gdb_read_byte(uint8_t ch)
2932 {
2933     uint8_t reply;
2934
2935 #ifndef CONFIG_USER_ONLY
2936     if (gdbserver_state.last_packet->len) {
2937         /* Waiting for a response to the last packet.  If we see the start
2938            of a new command then abandon the previous response.  */
2939         if (ch == '-') {
2940             trace_gdbstub_err_got_nack();
2941             put_buffer(gdbserver_state.last_packet->data,
2942                        gdbserver_state.last_packet->len);
2943         } else if (ch == '+') {
2944             trace_gdbstub_io_got_ack();
2945         } else {
2946             trace_gdbstub_io_got_unexpected(ch);
2947         }
2948
2949         if (ch == '+' || ch == '$') {
2950             g_byte_array_set_size(gdbserver_state.last_packet, 0);
2951         }
2952         if (ch != '$')
2953             return;
2954     }
2955     if (runstate_is_running()) {
2956         /* when the CPU is running, we cannot do anything except stop
2957            it when receiving a char */
2958         vm_stop(RUN_STATE_PAUSED);
2959     } else
2960 #endif
2961     {
2962         switch(gdbserver_state.state) {
2963         case RS_IDLE:
2964             if (ch == '$') {
2965                 /* start of command packet */
2966                 gdbserver_state.line_buf_index = 0;
2967                 gdbserver_state.line_sum = 0;
2968                 gdbserver_state.state = RS_GETLINE;
2969             } else {
2970                 trace_gdbstub_err_garbage(ch);
2971             }
2972             break;
2973         case RS_GETLINE:
2974             if (ch == '}') {
2975                 /* start escape sequence */
2976                 gdbserver_state.state = RS_GETLINE_ESC;
2977                 gdbserver_state.line_sum += ch;
2978             } else if (ch == '*') {
2979                 /* start run length encoding sequence */
2980                 gdbserver_state.state = RS_GETLINE_RLE;
2981                 gdbserver_state.line_sum += ch;
2982             } else if (ch == '#') {
2983                 /* end of command, start of checksum*/
2984                 gdbserver_state.state = RS_CHKSUM1;
2985             } else if (gdbserver_state.line_buf_index >= sizeof(gdbserver_state.line_buf) - 1) {
2986                 trace_gdbstub_err_overrun();
2987                 gdbserver_state.state = RS_IDLE;
2988             } else {
2989                 /* unescaped command character */
2990                 gdbserver_state.line_buf[gdbserver_state.line_buf_index++] = ch;
2991                 gdbserver_state.line_sum += ch;
2992             }
2993             break;
2994         case RS_GETLINE_ESC:
2995             if (ch == '#') {
2996                 /* unexpected end of command in escape sequence */
2997                 gdbserver_state.state = RS_CHKSUM1;
2998             } else if (gdbserver_state.line_buf_index >= sizeof(gdbserver_state.line_buf) - 1) {
2999                 /* command buffer overrun */
3000                 trace_gdbstub_err_overrun();
3001                 gdbserver_state.state = RS_IDLE;
3002             } else {
3003                 /* parse escaped character and leave escape state */
3004                 gdbserver_state.line_buf[gdbserver_state.line_buf_index++] = ch ^ 0x20;
3005                 gdbserver_state.line_sum += ch;
3006                 gdbserver_state.state = RS_GETLINE;
3007             }
3008             break;
3009         case RS_GETLINE_RLE:
3010             /*
3011              * Run-length encoding is explained in "Debugging with GDB /
3012              * Appendix E GDB Remote Serial Protocol / Overview".
3013              */
3014             if (ch < ' ' || ch == '#' || ch == '$' || ch > 126) {
3015                 /* invalid RLE count encoding */
3016                 trace_gdbstub_err_invalid_repeat(ch);
3017                 gdbserver_state.state = RS_GETLINE;
3018             } else {
3019                 /* decode repeat length */
3020                 int repeat = ch - ' ' + 3;
3021                 if (gdbserver_state.line_buf_index + repeat >= sizeof(gdbserver_state.line_buf) - 1) {
3022                     /* that many repeats would overrun the command buffer */
3023                     trace_gdbstub_err_overrun();
3024                     gdbserver_state.state = RS_IDLE;
3025                 } else if (gdbserver_state.line_buf_index < 1) {
3026                     /* got a repeat but we have nothing to repeat */
3027                     trace_gdbstub_err_invalid_rle();
3028                     gdbserver_state.state = RS_GETLINE;
3029                 } else {
3030                     /* repeat the last character */
3031                     memset(gdbserver_state.line_buf + gdbserver_state.line_buf_index,
3032                            gdbserver_state.line_buf[gdbserver_state.line_buf_index - 1], repeat);
3033                     gdbserver_state.line_buf_index += repeat;
3034                     gdbserver_state.line_sum += ch;
3035                     gdbserver_state.state = RS_GETLINE;
3036                 }
3037             }
3038             break;
3039         case RS_CHKSUM1:
3040             /* get high hex digit of checksum */
3041             if (!isxdigit(ch)) {
3042                 trace_gdbstub_err_checksum_invalid(ch);
3043                 gdbserver_state.state = RS_GETLINE;
3044                 break;
3045             }
3046             gdbserver_state.line_buf[gdbserver_state.line_buf_index] = '\0';
3047             gdbserver_state.line_csum = fromhex(ch) << 4;
3048             gdbserver_state.state = RS_CHKSUM2;
3049             break;
3050         case RS_CHKSUM2:
3051             /* get low hex digit of checksum */
3052             if (!isxdigit(ch)) {
3053                 trace_gdbstub_err_checksum_invalid(ch);
3054                 gdbserver_state.state = RS_GETLINE;
3055                 break;
3056             }
3057             gdbserver_state.line_csum |= fromhex(ch);
3058
3059             if (gdbserver_state.line_csum != (gdbserver_state.line_sum & 0xff)) {
3060                 trace_gdbstub_err_checksum_incorrect(gdbserver_state.line_sum, gdbserver_state.line_csum);
3061                 /* send NAK reply */
3062                 reply = '-';
3063                 put_buffer(&reply, 1);
3064                 gdbserver_state.state = RS_IDLE;
3065             } else {
3066                 /* send ACK reply */
3067                 reply = '+';
3068                 put_buffer(&reply, 1);
3069                 gdbserver_state.state = gdb_handle_packet(gdbserver_state.line_buf);
3070             }
3071             break;
3072         default:
3073             abort();
3074         }
3075     }
3076 }
3077
3078 /* Tell the remote gdb that the process has exited.  */
3079 void gdb_exit(int code)
3080 {
3081   char buf[4];
3082
3083   if (!gdbserver_state.init) {
3084       return;
3085   }
3086 #ifdef CONFIG_USER_ONLY
3087   if (gdbserver_state.socket_path) {
3088       unlink(gdbserver_state.socket_path);
3089   }
3090   if (gdbserver_state.fd < 0) {
3091       return;
3092   }
3093 #endif
3094
3095   trace_gdbstub_op_exiting((uint8_t)code);
3096
3097   snprintf(buf, sizeof(buf), "W%02x", (uint8_t)code);
3098   put_packet(buf);
3099
3100 #ifndef CONFIG_USER_ONLY
3101   qemu_chr_fe_deinit(&gdbserver_state.chr, true);
3102 #endif
3103 }
3104
3105 /*
3106  * Create the process that will contain all the "orphan" CPUs (that are not
3107  * part of a CPU cluster). Note that if this process contains no CPUs, it won't
3108  * be attachable and thus will be invisible to the user.
3109  */
3110 static void create_default_process(GDBState *s)
3111 {
3112     GDBProcess *process;
3113     int max_pid = 0;
3114
3115     if (gdbserver_state.process_num) {
3116         max_pid = s->processes[s->process_num - 1].pid;
3117     }
3118
3119     s->processes = g_renew(GDBProcess, s->processes, ++s->process_num);
3120     process = &s->processes[s->process_num - 1];
3121
3122     /* We need an available PID slot for this process */
3123     assert(max_pid < UINT32_MAX);
3124
3125     process->pid = max_pid + 1;
3126     process->attached = false;
3127     process->target_xml[0] = '\0';
3128 }
3129
3130 #ifdef CONFIG_USER_ONLY
3131 int
3132 gdb_handlesig(CPUState *cpu, int sig)
3133 {
3134     char buf[256];
3135     int n;
3136
3137     if (!gdbserver_state.init || gdbserver_state.fd < 0) {
3138         return sig;
3139     }
3140
3141     /* disable single step if it was enabled */
3142     cpu_single_step(cpu, 0);
3143     tb_flush(cpu);
3144
3145     if (sig != 0) {
3146         snprintf(buf, sizeof(buf), "S%02x", target_signal_to_gdb(sig));
3147         put_packet(buf);
3148     }
3149     /* put_packet() might have detected that the peer terminated the
3150        connection.  */
3151     if (gdbserver_state.fd < 0) {
3152         return sig;
3153     }
3154
3155     sig = 0;
3156     gdbserver_state.state = RS_IDLE;
3157     gdbserver_state.running_state = 0;
3158     while (gdbserver_state.running_state == 0) {
3159         n = read(gdbserver_state.fd, buf, 256);
3160         if (n > 0) {
3161             int i;
3162
3163             for (i = 0; i < n; i++) {
3164                 gdb_read_byte(buf[i]);
3165             }
3166         } else {
3167             /* XXX: Connection closed.  Should probably wait for another
3168                connection before continuing.  */
3169             if (n == 0) {
3170                 close(gdbserver_state.fd);
3171             }
3172             gdbserver_state.fd = -1;
3173             return sig;
3174         }
3175     }
3176     sig = gdbserver_state.signal;
3177     gdbserver_state.signal = 0;
3178     return sig;
3179 }
3180
3181 /* Tell the remote gdb that the process has exited due to SIG.  */
3182 void gdb_signalled(CPUArchState *env, int sig)
3183 {
3184     char buf[4];
3185
3186     if (!gdbserver_state.init || gdbserver_state.fd < 0) {
3187         return;
3188     }
3189
3190     snprintf(buf, sizeof(buf), "X%02x", target_signal_to_gdb(sig));
3191     put_packet(buf);
3192 }
3193
3194 static void gdb_accept_init(int fd)
3195 {
3196     init_gdbserver_state();
3197     create_default_process(&gdbserver_state);
3198     gdbserver_state.processes[0].attached = true;
3199     gdbserver_state.c_cpu = gdb_first_attached_cpu();
3200     gdbserver_state.g_cpu = gdbserver_state.c_cpu;
3201     gdbserver_state.fd = fd;
3202     gdb_has_xml = false;
3203 }
3204
3205 static bool gdb_accept_socket(int gdb_fd)
3206 {
3207     int fd;
3208
3209     for(;;) {
3210         fd = accept(gdb_fd, NULL, NULL);
3211         if (fd < 0 && errno != EINTR) {
3212             perror("accept socket");
3213             return false;
3214         } else if (fd >= 0) {
3215             qemu_set_cloexec(fd);
3216             break;
3217         }
3218     }
3219
3220     gdb_accept_init(fd);
3221     return true;
3222 }
3223
3224 static int gdbserver_open_socket(const char *path)
3225 {
3226     struct sockaddr_un sockaddr;
3227     int fd, ret;
3228
3229     fd = socket(AF_UNIX, SOCK_STREAM, 0);
3230     if (fd < 0) {
3231         perror("create socket");
3232         return -1;
3233     }
3234
3235     sockaddr.sun_family = AF_UNIX;
3236     pstrcpy(sockaddr.sun_path, sizeof(sockaddr.sun_path) - 1, path);
3237     ret = bind(fd, (struct sockaddr *)&sockaddr, sizeof(sockaddr));
3238     if (ret < 0) {
3239         perror("bind socket");
3240         close(fd);
3241         return -1;
3242     }
3243     ret = listen(fd, 1);
3244     if (ret < 0) {
3245         perror("listen socket");
3246         close(fd);
3247         return -1;
3248     }
3249
3250     return fd;
3251 }
3252
3253 static bool gdb_accept_tcp(int gdb_fd)
3254 {
3255     struct sockaddr_in sockaddr;
3256     socklen_t len;
3257     int fd;
3258
3259     for(;;) {
3260         len = sizeof(sockaddr);
3261         fd = accept(gdb_fd, (struct sockaddr *)&sockaddr, &len);
3262         if (fd < 0 && errno != EINTR) {
3263             perror("accept");
3264             return false;
3265         } else if (fd >= 0) {
3266             qemu_set_cloexec(fd);
3267             break;
3268         }
3269     }
3270
3271     /* set short latency */
3272     if (socket_set_nodelay(fd)) {
3273         perror("setsockopt");
3274         close(fd);
3275         return false;
3276     }
3277
3278     gdb_accept_init(fd);
3279     return true;
3280 }
3281
3282 static int gdbserver_open_port(int port)
3283 {
3284     struct sockaddr_in sockaddr;
3285     int fd, ret;
3286
3287     fd = socket(PF_INET, SOCK_STREAM, 0);
3288     if (fd < 0) {
3289         perror("socket");
3290         return -1;
3291     }
3292     qemu_set_cloexec(fd);
3293
3294     socket_set_fast_reuse(fd);
3295
3296     sockaddr.sin_family = AF_INET;
3297     sockaddr.sin_port = htons(port);
3298     sockaddr.sin_addr.s_addr = 0;
3299     ret = bind(fd, (struct sockaddr *)&sockaddr, sizeof(sockaddr));
3300     if (ret < 0) {
3301         perror("bind");
3302         close(fd);
3303         return -1;
3304     }
3305     ret = listen(fd, 1);
3306     if (ret < 0) {
3307         perror("listen");
3308         close(fd);
3309         return -1;
3310     }
3311
3312     return fd;
3313 }
3314
3315 int gdbserver_start(const char *port_or_path)
3316 {
3317     int port = g_ascii_strtoull(port_or_path, NULL, 10);
3318     int gdb_fd;
3319
3320     if (port > 0) {
3321         gdb_fd = gdbserver_open_port(port);
3322     } else {
3323         gdb_fd = gdbserver_open_socket(port_or_path);
3324     }
3325
3326     if (gdb_fd < 0) {
3327         return -1;
3328     }
3329
3330     if (port > 0 && gdb_accept_tcp(gdb_fd)) {
3331         return 0;
3332     } else if (gdb_accept_socket(gdb_fd)) {
3333         gdbserver_state.socket_path = g_strdup(port_or_path);
3334         return 0;
3335     }
3336
3337     /* gone wrong */
3338     close(gdb_fd);
3339     return -1;
3340 }
3341
3342 /* Disable gdb stub for child processes.  */
3343 void gdbserver_fork(CPUState *cpu)
3344 {
3345     if (!gdbserver_state.init || gdbserver_state.fd < 0) {
3346         return;
3347     }
3348     close(gdbserver_state.fd);
3349     gdbserver_state.fd = -1;
3350     cpu_breakpoint_remove_all(cpu, BP_GDB);
3351     cpu_watchpoint_remove_all(cpu, BP_GDB);
3352 }
3353 #else
3354 static int gdb_chr_can_receive(void *opaque)
3355 {
3356   /* We can handle an arbitrarily large amount of data.
3357    Pick the maximum packet size, which is as good as anything.  */
3358   return MAX_PACKET_LENGTH;
3359 }
3360
3361 static void gdb_chr_receive(void *opaque, const uint8_t *buf, int size)
3362 {
3363     int i;
3364
3365     for (i = 0; i < size; i++) {
3366         gdb_read_byte(buf[i]);
3367     }
3368 }
3369
3370 static void gdb_chr_event(void *opaque, QEMUChrEvent event)
3371 {
3372     int i;
3373     GDBState *s = (GDBState *) opaque;
3374
3375     switch (event) {
3376     case CHR_EVENT_OPENED:
3377         /* Start with first process attached, others detached */
3378         for (i = 0; i < s->process_num; i++) {
3379             s->processes[i].attached = !i;
3380         }
3381
3382         s->c_cpu = gdb_first_attached_cpu();
3383         s->g_cpu = s->c_cpu;
3384
3385         vm_stop(RUN_STATE_PAUSED);
3386         replay_gdb_attached();
3387         gdb_has_xml = false;
3388         break;
3389     default:
3390         break;
3391     }
3392 }
3393
3394 static int gdb_monitor_write(Chardev *chr, const uint8_t *buf, int len)
3395 {
3396     g_autoptr(GString) hex_buf = g_string_new("O");
3397     memtohex(hex_buf, buf, len);
3398     put_packet(hex_buf->str);
3399     return len;
3400 }
3401
3402 #ifndef _WIN32
3403 static void gdb_sigterm_handler(int signal)
3404 {
3405     if (runstate_is_running()) {
3406         vm_stop(RUN_STATE_PAUSED);
3407     }
3408 }
3409 #endif
3410
3411 static void gdb_monitor_open(Chardev *chr, ChardevBackend *backend,
3412                              bool *be_opened, Error **errp)
3413 {
3414     *be_opened = false;
3415 }
3416
3417 static void char_gdb_class_init(ObjectClass *oc, void *data)
3418 {
3419     ChardevClass *cc = CHARDEV_CLASS(oc);
3420
3421     cc->internal = true;
3422     cc->open = gdb_monitor_open;
3423     cc->chr_write = gdb_monitor_write;
3424 }
3425
3426 #define TYPE_CHARDEV_GDB "chardev-gdb"
3427
3428 static const TypeInfo char_gdb_type_info = {
3429     .name = TYPE_CHARDEV_GDB,
3430     .parent = TYPE_CHARDEV,
3431     .class_init = char_gdb_class_init,
3432 };
3433
3434 static int find_cpu_clusters(Object *child, void *opaque)
3435 {
3436     if (object_dynamic_cast(child, TYPE_CPU_CLUSTER)) {
3437         GDBState *s = (GDBState *) opaque;
3438         CPUClusterState *cluster = CPU_CLUSTER(child);
3439         GDBProcess *process;
3440
3441         s->processes = g_renew(GDBProcess, s->processes, ++s->process_num);
3442
3443         process = &s->processes[s->process_num - 1];
3444
3445         /*
3446          * GDB process IDs -1 and 0 are reserved. To avoid subtle errors at
3447          * runtime, we enforce here that the machine does not use a cluster ID
3448          * that would lead to PID 0.
3449          */
3450         assert(cluster->cluster_id != UINT32_MAX);
3451         process->pid = cluster->cluster_id + 1;
3452         process->attached = false;
3453         process->target_xml[0] = '\0';
3454
3455         return 0;
3456     }
3457
3458     return object_child_foreach(child, find_cpu_clusters, opaque);
3459 }
3460
3461 static int pid_order(const void *a, const void *b)
3462 {
3463     GDBProcess *pa = (GDBProcess *) a;
3464     GDBProcess *pb = (GDBProcess *) b;
3465
3466     if (pa->pid < pb->pid) {
3467         return -1;
3468     } else if (pa->pid > pb->pid) {
3469         return 1;
3470     } else {
3471         return 0;
3472     }
3473 }
3474
3475 static void create_processes(GDBState *s)
3476 {
3477     object_child_foreach(object_get_root(), find_cpu_clusters, s);
3478
3479     if (gdbserver_state.processes) {
3480         /* Sort by PID */
3481         qsort(gdbserver_state.processes, gdbserver_state.process_num, sizeof(gdbserver_state.processes[0]), pid_order);
3482     }
3483
3484     create_default_process(s);
3485 }
3486
3487 int gdbserver_start(const char *device)
3488 {
3489     trace_gdbstub_op_start(device);
3490
3491     char gdbstub_device_name[128];
3492     Chardev *chr = NULL;
3493     Chardev *mon_chr;
3494
3495     if (!first_cpu) {
3496         error_report("gdbstub: meaningless to attach gdb to a "
3497                      "machine without any CPU.");
3498         return -1;
3499     }
3500
3501     if (!device)
3502         return -1;
3503     if (strcmp(device, "none") != 0) {
3504         if (strstart(device, "tcp:", NULL)) {
3505             /* enforce required TCP attributes */
3506             snprintf(gdbstub_device_name, sizeof(gdbstub_device_name),
3507                      "%s,wait=off,nodelay=on,server=on", device);
3508             device = gdbstub_device_name;
3509         }
3510 #ifndef _WIN32
3511         else if (strcmp(device, "stdio") == 0) {
3512             struct sigaction act;
3513
3514             memset(&act, 0, sizeof(act));
3515             act.sa_handler = gdb_sigterm_handler;
3516             sigaction(SIGINT, &act, NULL);
3517         }
3518 #endif
3519         /*
3520          * FIXME: it's a bit weird to allow using a mux chardev here
3521          * and implicitly setup a monitor. We may want to break this.
3522          */
3523         chr = qemu_chr_new_noreplay("gdb", device, true, NULL);
3524         if (!chr)
3525             return -1;
3526     }
3527
3528     if (!gdbserver_state.init) {
3529         init_gdbserver_state();
3530
3531         qemu_add_vm_change_state_handler(gdb_vm_state_change, NULL);
3532
3533         /* Initialize a monitor terminal for gdb */
3534         mon_chr = qemu_chardev_new(NULL, TYPE_CHARDEV_GDB,
3535                                    NULL, NULL, &error_abort);
3536         monitor_init_hmp(mon_chr, false, &error_abort);
3537     } else {
3538         qemu_chr_fe_deinit(&gdbserver_state.chr, true);
3539         mon_chr = gdbserver_state.mon_chr;
3540         reset_gdbserver_state();
3541     }
3542
3543     create_processes(&gdbserver_state);
3544
3545     if (chr) {
3546         qemu_chr_fe_init(&gdbserver_state.chr, chr, &error_abort);
3547         qemu_chr_fe_set_handlers(&gdbserver_state.chr, gdb_chr_can_receive,
3548                                  gdb_chr_receive, gdb_chr_event,
3549                                  NULL, &gdbserver_state, NULL, true);
3550     }
3551     gdbserver_state.state = chr ? RS_IDLE : RS_INACTIVE;
3552     gdbserver_state.mon_chr = mon_chr;
3553     gdbserver_state.current_syscall_cb = NULL;
3554
3555     return 0;
3556 }
3557
3558 static void register_types(void)
3559 {
3560     type_register_static(&char_gdb_type_info);
3561 }
3562
3563 type_init(register_types);
3564 #endif