gdbstub.c

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