gdbstub.c

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