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