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