gdbstub/gdbstub.c

   1 /*
   2  * gdb server stub
   3  *
   4  * This implements a subset of the remote protocol as described in:
   5  *
   6  *   https://sourceware.org/gdb/onlinedocs/gdb/Remote-Protocol.html
   7  *
   8  * Copyright (c) 2003-2005 Fabrice Bellard
   9  *
  10  * This library is free software; you can redistribute it and/or
  11  * modify it under the terms of the GNU Lesser General Public
  12  * License as published by the Free Software Foundation; either
  13  * version 2 of the License, or (at your option) any later version.
  14  *
  15  * This library is distributed in the hope that it will be useful,
  16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  18  * Lesser General Public License for more details.
  19  *
  20  * You should have received a copy of the GNU Lesser General Public
  21  * License along with this library; if not, see <http://www.gnu.org/licenses/>.
  22  *
  23  * SPDX-License-Identifier: LGPL-2.0-or-later
  24  */
  25
  26 #include "qemu/osdep.h"
  27 #include "qemu/ctype.h"
  28 #include "qemu/cutils.h"
  29 #include "qemu/module.h"
  30 #include "qemu/error-report.h"
  31 #include "trace.h"
  32 #include "exec/gdbstub.h"
  33 #include "gdbstub/commands.h"
  34 #include "gdbstub/syscalls.h"
  35 #ifdef CONFIG_USER_ONLY
  36 #include "accel/tcg/vcpu-state.h"
  37 #include "gdbstub/user.h"
  38 #else
  39 #include "hw/cpu/cluster.h"
  40 #include "hw/boards.h"
  41 #endif
  42 #include "hw/core/cpu.h"
  43
  44 #include "sysemu/hw_accel.h"
  45 #include "sysemu/runstate.h"
  46 #include "exec/replay-core.h"
  47 #include "exec/hwaddr.h"
  48
  49 #include "internals.h"
  50
  51 typedef struct GDBRegisterState {
  52     int base_reg;
  53     gdb_get_reg_cb get_reg;
  54     gdb_set_reg_cb set_reg;
  55     const GDBFeature *feature;
  56 } GDBRegisterState;
  57
  58 GDBState gdbserver_state;
  59
  60 void gdb_init_gdbserver_state(void)
  61 {
  62     g_assert(!gdbserver_state.init);
  63     memset(&gdbserver_state, 0, sizeof(GDBState));
  64     gdbserver_state.init = true;
  65     gdbserver_state.str_buf = g_string_new(NULL);
  66     gdbserver_state.mem_buf = g_byte_array_sized_new(MAX_PACKET_LENGTH);
  67     gdbserver_state.last_packet = g_byte_array_sized_new(MAX_PACKET_LENGTH + 4);
  68
  69     /*
  70      * What single-step modes are supported is accelerator dependent.
  71      * By default try to use no IRQs and no timers while single
  72      * stepping so as to make single stepping like a typical ICE HW step.
  73      */
  74     gdbserver_state.supported_sstep_flags = accel_supported_gdbstub_sstep_flags();
  75     gdbserver_state.sstep_flags = SSTEP_ENABLE | SSTEP_NOIRQ | SSTEP_NOTIMER;
  76     gdbserver_state.sstep_flags &= gdbserver_state.supported_sstep_flags;
  77 }
  78
  79 /* writes 2*len+1 bytes in buf */
  80 void gdb_memtohex(GString *buf, const uint8_t *mem, int len)
  81 {
  82     int i, c;
  83     for(i = 0; i < len; i++) {
  84         c = mem[i];
  85         g_string_append_c(buf, tohex(c >> 4));
  86         g_string_append_c(buf, tohex(c & 0xf));
  87     }
  88     g_string_append_c(buf, '\0');
  89 }
  90
  91 void gdb_hextomem(GByteArray *mem, const char *buf, int len)
  92 {
  93     int i;
  94
  95     for(i = 0; i < len; i++) {
  96         guint8 byte = fromhex(buf[0]) << 4 | fromhex(buf[1]);
  97         g_byte_array_append(mem, &byte, 1);
  98         buf += 2;
  99     }
 100 }
 101
 102 static void hexdump(const char *buf, int len,
 103                     void (*trace_fn)(size_t ofs, char const *text))
 104 {
 105     char line_buffer[3 * 16 + 4 + 16 + 1];
 106
 107     size_t i;
 108     for (i = 0; i < len || (i & 0xF); ++i) {
 109         size_t byte_ofs = i & 15;
 110
 111         if (byte_ofs == 0) {
 112             memset(line_buffer, ' ', 3 * 16 + 4 + 16);
 113             line_buffer[3 * 16 + 4 + 16] = 0;
 114         }
 115
 116         size_t col_group = (i >> 2) & 3;
 117         size_t hex_col = byte_ofs * 3 + col_group;
 118         size_t txt_col = 3 * 16 + 4 + byte_ofs;
 119
 120         if (i < len) {
 121             char value = buf[i];
 122
 123             line_buffer[hex_col + 0] = tohex((value >> 4) & 0xF);
 124             line_buffer[hex_col + 1] = tohex((value >> 0) & 0xF);
 125             line_buffer[txt_col + 0] = (value >= ' ' && value < 127)
 126                     ? value
 127                     : '.';
 128         }
 129
 130         if (byte_ofs == 0xF)
 131             trace_fn(i & -16, line_buffer);
 132     }
 133 }
 134
 135 /* return -1 if error, 0 if OK */
 136 int gdb_put_packet_binary(const char *buf, int len, bool dump)
 137 {
 138     int csum, i;
 139     uint8_t footer[3];
 140
 141     if (dump && trace_event_get_state_backends(TRACE_GDBSTUB_IO_BINARYREPLY)) {
 142         hexdump(buf, len, trace_gdbstub_io_binaryreply);
 143     }
 144
 145     for(;;) {
 146         g_byte_array_set_size(gdbserver_state.last_packet, 0);
 147         g_byte_array_append(gdbserver_state.last_packet,
 148                             (const uint8_t *) "$", 1);
 149         g_byte_array_append(gdbserver_state.last_packet,
 150                             (const uint8_t *) buf, len);
 151         csum = 0;
 152         for(i = 0; i < len; i++) {
 153             csum += buf[i];
 154         }
 155         footer[0] = '#';
 156         footer[1] = tohex((csum >> 4) & 0xf);
 157         footer[2] = tohex((csum) & 0xf);
 158         g_byte_array_append(gdbserver_state.last_packet, footer, 3);
 159
 160         gdb_put_buffer(gdbserver_state.last_packet->data,
 161                    gdbserver_state.last_packet->len);
 162
 163         if (gdb_got_immediate_ack()) {
 164             break;
 165         }
 166     }
 167     return 0;
 168 }
 169
 170 /* return -1 if error, 0 if OK */
 171 int gdb_put_packet(const char *buf)
 172 {
 173     trace_gdbstub_io_reply(buf);
 174
 175     return gdb_put_packet_binary(buf, strlen(buf), false);
 176 }
 177
 178 void gdb_put_strbuf(void)
 179 {
 180     gdb_put_packet(gdbserver_state.str_buf->str);
 181 }
 182
 183 /* Encode data using the encoding for 'x' packets.  */
 184 void gdb_memtox(GString *buf, const char *mem, int len)
 185 {
 186     char c;
 187
 188     while (len--) {
 189         c = *(mem++);
 190         switch (c) {
 191         case '#': case '$': case '*': case '}':
 192             g_string_append_c(buf, '}');
 193             g_string_append_c(buf, c ^ 0x20);
 194             break;
 195         default:
 196             g_string_append_c(buf, c);
 197             break;
 198         }
 199     }
 200 }
 201
 202 static uint32_t gdb_get_cpu_pid(CPUState *cpu)
 203 {
 204 #ifdef CONFIG_USER_ONLY
 205     return getpid();
 206 #else
 207     if (cpu->cluster_index == UNASSIGNED_CLUSTER_INDEX) {
 208         /* Return the default process' PID */
 209         int index = gdbserver_state.process_num - 1;
 210         return gdbserver_state.processes[index].pid;
 211     }
 212     return cpu->cluster_index + 1;
 213 #endif
 214 }
 215
 216 GDBProcess *gdb_get_process(uint32_t pid)
 217 {
 218     int i;
 219
 220     if (!pid) {
 221         /* 0 means any process, we take the first one */
 222         return &gdbserver_state.processes[0];
 223     }
 224
 225     for (i = 0; i < gdbserver_state.process_num; i++) {
 226         if (gdbserver_state.processes[i].pid == pid) {
 227             return &gdbserver_state.processes[i];
 228         }
 229     }
 230
 231     return NULL;
 232 }
 233
 234 static GDBProcess *gdb_get_cpu_process(CPUState *cpu)
 235 {
 236     return gdb_get_process(gdb_get_cpu_pid(cpu));
 237 }
 238
 239 static CPUState *find_cpu(uint32_t thread_id)
 240 {
 241     CPUState *cpu;
 242
 243     CPU_FOREACH(cpu) {
 244         if (gdb_get_cpu_index(cpu) == thread_id) {
 245             return cpu;
 246         }
 247     }
 248
 249     return NULL;
 250 }
 251
 252 CPUState *gdb_get_first_cpu_in_process(GDBProcess *process)
 253 {
 254     CPUState *cpu;
 255
 256     CPU_FOREACH(cpu) {
 257         if (gdb_get_cpu_pid(cpu) == process->pid) {
 258             return cpu;
 259         }
 260     }
 261
 262     return NULL;
 263 }
 264
 265 static CPUState *gdb_next_cpu_in_process(CPUState *cpu)
 266 {
 267     uint32_t pid = gdb_get_cpu_pid(cpu);
 268     cpu = CPU_NEXT(cpu);
 269
 270     while (cpu) {
 271         if (gdb_get_cpu_pid(cpu) == pid) {
 272             break;
 273         }
 274
 275         cpu = CPU_NEXT(cpu);
 276     }
 277
 278     return cpu;
 279 }
 280
 281 /* Return the cpu following @cpu, while ignoring unattached processes. */
 282 static CPUState *gdb_next_attached_cpu(CPUState *cpu)
 283 {
 284     cpu = CPU_NEXT(cpu);
 285
 286     while (cpu) {
 287         if (gdb_get_cpu_process(cpu)->attached) {
 288             break;
 289         }
 290
 291         cpu = CPU_NEXT(cpu);
 292     }
 293
 294     return cpu;
 295 }
 296
 297 /* Return the first attached cpu */
 298 CPUState *gdb_first_attached_cpu(void)
 299 {
 300     CPUState *cpu = first_cpu;
 301     GDBProcess *process = gdb_get_cpu_process(cpu);
 302
 303     if (!process->attached) {
 304         return gdb_next_attached_cpu(cpu);
 305     }
 306
 307     return cpu;
 308 }
 309
 310 static CPUState *gdb_get_cpu(uint32_t pid, uint32_t tid)
 311 {
 312     GDBProcess *process;
 313     CPUState *cpu;
 314
 315     if (!pid && !tid) {
 316         /* 0 means any process/thread, we take the first attached one */
 317         return gdb_first_attached_cpu();
 318     } else if (pid && !tid) {
 319         /* any thread in a specific process */
 320         process = gdb_get_process(pid);
 321
 322         if (process == NULL) {
 323             return NULL;
 324         }
 325
 326         if (!process->attached) {
 327             return NULL;
 328         }
 329
 330         return gdb_get_first_cpu_in_process(process);
 331     } else {
 332         /* a specific thread */
 333         cpu = find_cpu(tid);
 334
 335         if (cpu == NULL) {
 336             return NULL;
 337         }
 338
 339         process = gdb_get_cpu_process(cpu);
 340
 341         if (pid && process->pid != pid) {
 342             return NULL;
 343         }
 344
 345         if (!process->attached) {
 346             return NULL;
 347         }
 348
 349         return cpu;
 350     }
 351 }
 352
 353 static const char *get_feature_xml(const char *p, const char **newp,
 354                                    GDBProcess *process)
 355 {
 356     CPUState *cpu = gdb_get_first_cpu_in_process(process);
 357     CPUClass *cc = CPU_GET_CLASS(cpu);
 358     GDBRegisterState *r;
 359     size_t len;
 360
 361     /*
 362      * qXfer:features:read:ANNEX:OFFSET,LENGTH'
 363      *                     ^p    ^newp
 364      */
 365     char *term = strchr(p, ':');
 366     *newp = term + 1;
 367     len = term - p;
 368
 369     /* Is it the main target xml? */
 370     if (strncmp(p, "target.xml", len) == 0) {
 371         if (!process->target_xml) {
 372             g_autoptr(GPtrArray) xml = g_ptr_array_new_with_free_func(g_free);
 373
 374             g_ptr_array_add(
 375                 xml,
 376                 g_strdup("<?xml version=\"1.0\"?>"
 377                          "<!DOCTYPE target SYSTEM \"gdb-target.dtd\">"
 378                          "<target>"));
 379
 380             if (cc->gdb_arch_name) {
 381                 g_ptr_array_add(
 382                     xml,
 383                     g_markup_printf_escaped("<architecture>%s</architecture>",
 384                                             cc->gdb_arch_name(cpu)));
 385             }
 386             for (guint i = 0; i < cpu->gdb_regs->len; i++) {
 387                 r = &g_array_index(cpu->gdb_regs, GDBRegisterState, i);
 388                 g_ptr_array_add(
 389                     xml,
 390                     g_markup_printf_escaped("<xi:include href=\"%s\"/>",
 391                                             r->feature->xmlname));
 392             }
 393             g_ptr_array_add(xml, g_strdup("</target>"));
 394             g_ptr_array_add(xml, NULL);
 395
 396             process->target_xml = g_strjoinv(NULL, (void *)xml->pdata);
 397         }
 398         return process->target_xml;
 399     }
 400     /* Is it one of the features? */
 401     for (guint i = 0; i < cpu->gdb_regs->len; i++) {
 402         r = &g_array_index(cpu->gdb_regs, GDBRegisterState, i);
 403         if (strncmp(p, r->feature->xmlname, len) == 0) {
 404             return r->feature->xml;
 405         }
 406     }
 407
 408     /* failed */
 409     return NULL;
 410 }
 411
 412 void gdb_feature_builder_init(GDBFeatureBuilder *builder, GDBFeature *feature,
 413                               const char *name, const char *xmlname,
 414                               int base_reg)
 415 {
 416     char *header = g_markup_printf_escaped(
 417         "<?xml version=\"1.0\"?>"
 418         "<!DOCTYPE feature SYSTEM \"gdb-target.dtd\">"
 419         "<feature name=\"%s\">",
 420         name);
 421
 422     builder->feature = feature;
 423     builder->xml = g_ptr_array_new();
 424     g_ptr_array_add(builder->xml, header);
 425     builder->regs = g_ptr_array_new();
 426     builder->base_reg = base_reg;
 427     feature->xmlname = xmlname;
 428     feature->name = name;
 429 }
 430
 431 void gdb_feature_builder_append_tag(const GDBFeatureBuilder *builder,
 432                                     const char *format, ...)
 433 {
 434     va_list ap;
 435     va_start(ap, format);
 436     g_ptr_array_add(builder->xml, g_markup_vprintf_escaped(format, ap));
 437     va_end(ap);
 438 }
 439
 440 void gdb_feature_builder_append_reg(const GDBFeatureBuilder *builder,
 441                                     const char *name,
 442                                     int bitsize,
 443                                     int regnum,
 444                                     const char *type,
 445                                     const char *group)
 446 {
 447     if (builder->regs->len <= regnum) {
 448         g_ptr_array_set_size(builder->regs, regnum + 1);
 449     }
 450
 451     builder->regs->pdata[regnum] = (gpointer *)name;
 452
 453     if (group) {
 454         gdb_feature_builder_append_tag(
 455             builder,
 456             "<reg name=\"%s\" bitsize=\"%d\" regnum=\"%d\" type=\"%s\" group=\"%s\"/>",
 457             name, bitsize, builder->base_reg + regnum, type, group);
 458     } else {
 459         gdb_feature_builder_append_tag(
 460             builder,
 461             "<reg name=\"%s\" bitsize=\"%d\" regnum=\"%d\" type=\"%s\"/>",
 462             name, bitsize, builder->base_reg + regnum, type);
 463     }
 464 }
 465
 466 void gdb_feature_builder_end(const GDBFeatureBuilder *builder)
 467 {
 468     g_ptr_array_add(builder->xml, (void *)"</feature>");
 469     g_ptr_array_add(builder->xml, NULL);
 470
 471     builder->feature->xml = g_strjoinv(NULL, (void *)builder->xml->pdata);
 472
 473     for (guint i = 0; i < builder->xml->len - 2; i++) {
 474         g_free(g_ptr_array_index(builder->xml, i));
 475     }
 476
 477     g_ptr_array_free(builder->xml, TRUE);
 478
 479     builder->feature->num_regs = builder->regs->len;
 480     builder->feature->regs = (void *)g_ptr_array_free(builder->regs, FALSE);
 481 }
 482
 483 const GDBFeature *gdb_find_static_feature(const char *xmlname)
 484 {
 485     const GDBFeature *feature;
 486
 487     for (feature = gdb_static_features; feature->xmlname; feature++) {
 488         if (!strcmp(feature->xmlname, xmlname)) {
 489             return feature;
 490         }
 491     }
 492
 493     g_assert_not_reached();
 494 }
 495
 496 GArray *gdb_get_register_list(CPUState *cpu)
 497 {
 498     GArray *results = g_array_new(true, true, sizeof(GDBRegDesc));
 499
 500     /* registers are only available once the CPU is initialised */
 501     if (!cpu->gdb_regs) {
 502         return results;
 503     }
 504
 505     for (int f = 0; f < cpu->gdb_regs->len; f++) {
 506         GDBRegisterState *r = &g_array_index(cpu->gdb_regs, GDBRegisterState, f);
 507         for (int i = 0; i < r->feature->num_regs; i++) {
 508             const char *name = r->feature->regs[i];
 509             GDBRegDesc desc = {
 510                 r->base_reg + i,
 511                 name,
 512                 r->feature->name
 513             };
 514             g_array_append_val(results, desc);
 515         }
 516     }
 517
 518     return results;
 519 }
 520
 521 int gdb_read_register(CPUState *cpu, GByteArray *buf, int reg)
 522 {
 523     CPUClass *cc = CPU_GET_CLASS(cpu);
 524     GDBRegisterState *r;
 525
 526     if (reg < cc->gdb_num_core_regs) {
 527         return cc->gdb_read_register(cpu, buf, reg);
 528     }
 529
 530     for (guint i = 0; i < cpu->gdb_regs->len; i++) {
 531         r = &g_array_index(cpu->gdb_regs, GDBRegisterState, i);
 532         if (r->base_reg <= reg && reg < r->base_reg + r->feature->num_regs) {
 533             return r->get_reg(cpu, buf, reg - r->base_reg);
 534         }
 535     }
 536     return 0;
 537 }
 538
 539 static int gdb_write_register(CPUState *cpu, uint8_t *mem_buf, int reg)
 540 {
 541     CPUClass *cc = CPU_GET_CLASS(cpu);
 542     GDBRegisterState *r;
 543
 544     if (reg < cc->gdb_num_core_regs) {
 545         return cc->gdb_write_register(cpu, mem_buf, reg);
 546     }
 547
 548     for (guint i = 0; i < cpu->gdb_regs->len; i++) {
 549         r =  &g_array_index(cpu->gdb_regs, GDBRegisterState, i);
 550         if (r->base_reg <= reg && reg < r->base_reg + r->feature->num_regs) {
 551             return r->set_reg(cpu, mem_buf, reg - r->base_reg);
 552         }
 553     }
 554     return 0;
 555 }
 556
 557 static void gdb_register_feature(CPUState *cpu, int base_reg,
 558                                  gdb_get_reg_cb get_reg, gdb_set_reg_cb set_reg,
 559                                  const GDBFeature *feature)
 560 {
 561     GDBRegisterState s = {
 562         .base_reg = base_reg,
 563         .get_reg = get_reg,
 564         .set_reg = set_reg,
 565         .feature = feature
 566     };
 567
 568     g_array_append_val(cpu->gdb_regs, s);
 569 }
 570
 571 void gdb_init_cpu(CPUState *cpu)
 572 {
 573     CPUClass *cc = CPU_GET_CLASS(cpu);
 574     const GDBFeature *feature;
 575
 576     cpu->gdb_regs = g_array_new(false, false, sizeof(GDBRegisterState));
 577
 578     if (cc->gdb_core_xml_file) {
 579         feature = gdb_find_static_feature(cc->gdb_core_xml_file);
 580         gdb_register_feature(cpu, 0,
 581                              cc->gdb_read_register, cc->gdb_write_register,
 582                              feature);
 583         cpu->gdb_num_regs = cpu->gdb_num_g_regs = feature->num_regs;
 584     }
 585
 586     if (cc->gdb_num_core_regs) {
 587         cpu->gdb_num_regs = cpu->gdb_num_g_regs = cc->gdb_num_core_regs;
 588     }
 589 }
 590
 591 void gdb_register_coprocessor(CPUState *cpu,
 592                               gdb_get_reg_cb get_reg, gdb_set_reg_cb set_reg,
 593                               const GDBFeature *feature, int g_pos)
 594 {
 595     GDBRegisterState *s;
 596     guint i;
 597     int base_reg = cpu->gdb_num_regs;
 598
 599     for (i = 0; i < cpu->gdb_regs->len; i++) {
 600         /* Check for duplicates.  */
 601         s = &g_array_index(cpu->gdb_regs, GDBRegisterState, i);
 602         if (s->feature == feature) {
 603             return;
 604         }
 605     }
 606
 607     gdb_register_feature(cpu, base_reg, get_reg, set_reg, feature);
 608
 609     /* Add to end of list.  */
 610     cpu->gdb_num_regs += feature->num_regs;
 611     if (g_pos) {
 612         if (g_pos != base_reg) {
 613             error_report("Error: Bad gdb register numbering for '%s', "
 614                          "expected %d got %d", feature->xml, g_pos, base_reg);
 615         } else {
 616             cpu->gdb_num_g_regs = cpu->gdb_num_regs;
 617         }
 618     }
 619 }
 620
 621 void gdb_unregister_coprocessor_all(CPUState *cpu)
 622 {
 623     /*
 624      * Safe to nuke everything. GDBRegisterState::xml is static const char so
 625      * it won't be freed
 626      */
 627     g_array_free(cpu->gdb_regs, true);
 628
 629     cpu->gdb_regs = NULL;
 630     cpu->gdb_num_regs = 0;
 631     cpu->gdb_num_g_regs = 0;
 632 }
 633
 634 static void gdb_process_breakpoint_remove_all(GDBProcess *p)
 635 {
 636     CPUState *cpu = gdb_get_first_cpu_in_process(p);
 637
 638     while (cpu) {
 639         gdb_breakpoint_remove_all(cpu);
 640         cpu = gdb_next_cpu_in_process(cpu);
 641     }
 642 }
 643
 644
 645 static void gdb_set_cpu_pc(vaddr pc)
 646 {
 647     CPUState *cpu = gdbserver_state.c_cpu;
 648
 649     cpu_synchronize_state(cpu);
 650     cpu_set_pc(cpu, pc);
 651 }
 652
 653 void gdb_append_thread_id(CPUState *cpu, GString *buf)
 654 {
 655     if (gdbserver_state.multiprocess) {
 656         g_string_append_printf(buf, "p%02x.%02x",
 657                                gdb_get_cpu_pid(cpu), gdb_get_cpu_index(cpu));
 658     } else {
 659         g_string_append_printf(buf, "%02x", gdb_get_cpu_index(cpu));
 660     }
 661 }
 662
 663 static GDBThreadIdKind read_thread_id(const char *buf, const char **end_buf,
 664                                       uint32_t *pid, uint32_t *tid)
 665 {
 666     unsigned long p, t;
 667     int ret;
 668
 669     if (*buf == 'p') {
 670         buf++;
 671         ret = qemu_strtoul(buf, &buf, 16, &p);
 672
 673         if (ret) {
 674             return GDB_READ_THREAD_ERR;
 675         }
 676
 677         /* Skip '.' */
 678         buf++;
 679     } else {
 680         p = 0;
 681     }
 682
 683     ret = qemu_strtoul(buf, &buf, 16, &t);
 684
 685     if (ret) {
 686         return GDB_READ_THREAD_ERR;
 687     }
 688
 689     *end_buf = buf;
 690
 691     if (p == -1) {
 692         return GDB_ALL_PROCESSES;
 693     }
 694
 695     if (pid) {
 696         *pid = p;
 697     }
 698
 699     if (t == -1) {
 700         return GDB_ALL_THREADS;
 701     }
 702
 703     if (tid) {
 704         *tid = t;
 705     }
 706
 707     return GDB_ONE_THREAD;
 708 }
 709
 710 /**
 711  * gdb_handle_vcont - Parses and handles a vCont packet.
 712  * returns -ENOTSUP if a command is unsupported, -EINVAL or -ERANGE if there is
 713  *         a format error, 0 on success.
 714  */
 715 static int gdb_handle_vcont(const char *p)
 716 {
 717     int res, signal = 0;
 718     char cur_action;
 719     unsigned long tmp;
 720     uint32_t pid, tid;
 721     GDBProcess *process;
 722     CPUState *cpu;
 723     GDBThreadIdKind kind;
 724     unsigned int max_cpus = gdb_get_max_cpus();
 725     /* uninitialised CPUs stay 0 */
 726     g_autofree char *newstates = g_new0(char, max_cpus);
 727
 728     /* mark valid CPUs with 1 */
 729     CPU_FOREACH(cpu) {
 730         newstates[cpu->cpu_index] = 1;
 731     }
 732
 733     /*
 734      * res keeps track of what error we are returning, with -ENOTSUP meaning
 735      * that the command is unknown or unsupported, thus returning an empty
 736      * packet, while -EINVAL and -ERANGE cause an E22 packet, due to invalid,
 737      *  or incorrect parameters passed.
 738      */
 739     res = 0;
 740
 741     /*
 742      * target_count and last_target keep track of how many CPUs we are going to
 743      * step or resume, and a pointer to the state structure of one of them,
 744      * respectively
 745      */
 746     int target_count = 0;
 747     CPUState *last_target = NULL;
 748
 749     while (*p) {
 750         if (*p++ != ';') {
 751             return -ENOTSUP;
 752         }
 753
 754         cur_action = *p++;
 755         if (cur_action == 'C' || cur_action == 'S') {
 756             cur_action = qemu_tolower(cur_action);
 757             res = qemu_strtoul(p, &p, 16, &tmp);
 758             if (res) {
 759                 return res;
 760             }
 761             signal = gdb_signal_to_target(tmp);
 762         } else if (cur_action != 'c' && cur_action != 's') {
 763             /* unknown/invalid/unsupported command */
 764             return -ENOTSUP;
 765         }
 766
 767         if (*p == '\0' || *p == ';') {
 768             /*
 769              * No thread specifier, action is on "all threads". The
 770              * specification is unclear regarding the process to act on. We
 771              * choose all processes.
 772              */
 773             kind = GDB_ALL_PROCESSES;
 774         } else if (*p++ == ':') {
 775             kind = read_thread_id(p, &p, &pid, &tid);
 776         } else {
 777             return -ENOTSUP;
 778         }
 779
 780         switch (kind) {
 781         case GDB_READ_THREAD_ERR:
 782             return -EINVAL;
 783
 784         case GDB_ALL_PROCESSES:
 785             cpu = gdb_first_attached_cpu();
 786             while (cpu) {
 787                 if (newstates[cpu->cpu_index] == 1) {
 788                     newstates[cpu->cpu_index] = cur_action;
 789
 790                     target_count++;
 791                     last_target = cpu;
 792                 }
 793
 794                 cpu = gdb_next_attached_cpu(cpu);
 795             }
 796             break;
 797
 798         case GDB_ALL_THREADS:
 799             process = gdb_get_process(pid);
 800
 801             if (!process->attached) {
 802                 return -EINVAL;
 803             }
 804
 805             cpu = gdb_get_first_cpu_in_process(process);
 806             while (cpu) {
 807                 if (newstates[cpu->cpu_index] == 1) {
 808                     newstates[cpu->cpu_index] = cur_action;
 809
 810                     target_count++;
 811                     last_target = cpu;
 812                 }
 813
 814                 cpu = gdb_next_cpu_in_process(cpu);
 815             }
 816             break;
 817
 818         case GDB_ONE_THREAD:
 819             cpu = gdb_get_cpu(pid, tid);
 820
 821             /* invalid CPU/thread specified */
 822             if (!cpu) {
 823                 return -EINVAL;
 824             }
 825
 826             /* only use if no previous match occourred */
 827             if (newstates[cpu->cpu_index] == 1) {
 828                 newstates[cpu->cpu_index] = cur_action;
 829
 830                 target_count++;
 831                 last_target = cpu;
 832             }
 833             break;
 834         }
 835     }
 836
 837     /*
 838      * if we're about to resume a specific set of CPUs/threads, make it so that
 839      * in case execution gets interrupted, we can send GDB a stop reply with a
 840      * correct value. it doesn't really matter which CPU we tell GDB the signal
 841      * happened in (VM pauses stop all of them anyway), so long as it is one of
 842      * the ones we resumed/single stepped here.
 843      */
 844     if (target_count > 0) {
 845         gdbserver_state.c_cpu = last_target;
 846     }
 847
 848     gdbserver_state.signal = signal;
 849     gdb_continue_partial(newstates);
 850     return res;
 851 }
 852
 853 static const char *cmd_next_param(const char *param, const char delimiter)
 854 {
 855     static const char all_delimiters[] = ",;:=";
 856     char curr_delimiters[2] = {0};
 857     const char *delimiters;
 858
 859     if (delimiter == '?') {
 860         delimiters = all_delimiters;
 861     } else if (delimiter == '0') {
 862         return strchr(param, '\0');
 863     } else if (delimiter == '.' && *param) {
 864         return param + 1;
 865     } else {
 866         curr_delimiters[0] = delimiter;
 867         delimiters = curr_delimiters;
 868     }
 869
 870     param += strcspn(param, delimiters);
 871     if (*param) {
 872         param++;
 873     }
 874     return param;
 875 }
 876
 877 static int cmd_parse_params(const char *data, const char *schema,
 878                             GArray *params)
 879 {
 880     const char *curr_schema, *curr_data;
 881
 882     g_assert(schema);
 883     g_assert(params->len == 0);
 884
 885     curr_schema = schema;
 886     curr_data = data;
 887     while (curr_schema[0] && curr_schema[1] && *curr_data) {
 888         GdbCmdVariant this_param;
 889
 890         switch (curr_schema[0]) {
 891         case 'l':
 892             if (qemu_strtoul(curr_data, &curr_data, 16,
 893                              &this_param.val_ul)) {
 894                 return -EINVAL;
 895             }
 896             curr_data = cmd_next_param(curr_data, curr_schema[1]);
 897             g_array_append_val(params, this_param);
 898             break;
 899         case 'L':
 900             if (qemu_strtou64(curr_data, &curr_data, 16,
 901                               (uint64_t *)&this_param.val_ull)) {
 902                 return -EINVAL;
 903             }
 904             curr_data = cmd_next_param(curr_data, curr_schema[1]);
 905             g_array_append_val(params, this_param);
 906             break;
 907         case 's':
 908             this_param.data = curr_data;
 909             curr_data = cmd_next_param(curr_data, curr_schema[1]);
 910             g_array_append_val(params, this_param);
 911             break;
 912         case 'o':
 913             this_param.opcode = *(uint8_t *)curr_data;
 914             curr_data = cmd_next_param(curr_data, curr_schema[1]);
 915             g_array_append_val(params, this_param);
 916             break;
 917         case 't':
 918             this_param.thread_id.kind =
 919                 read_thread_id(curr_data, &curr_data,
 920                                &this_param.thread_id.pid,
 921                                &this_param.thread_id.tid);
 922             curr_data = cmd_next_param(curr_data, curr_schema[1]);
 923             g_array_append_val(params, this_param);
 924             break;
 925         case '?':
 926             curr_data = cmd_next_param(curr_data, curr_schema[1]);
 927             break;
 928         default:
 929             return -EINVAL;
 930         }
 931         curr_schema += 2;
 932     }
 933
 934     return 0;
 935 }
 936
 937 static inline int startswith(const char *string, const char *pattern)
 938 {
 939   return !strncmp(string, pattern, strlen(pattern));
 940 }
 941
 942 static bool process_string_cmd(const char *data,
 943                                const GdbCmdParseEntry *cmds, int num_cmds)
 944 {
 945     int i;
 946     g_autoptr(GArray) params = g_array_new(false, true, sizeof(GdbCmdVariant));
 947
 948     if (!cmds) {
 949         return false;
 950     }
 951
 952     for (i = 0; i < num_cmds; i++) {
 953         const GdbCmdParseEntry *cmd = &cmds[i];
 954         void *user_ctx = NULL;
 955         g_assert(cmd->handler && cmd->cmd);
 956
 957         if ((cmd->cmd_startswith && !startswith(data, cmd->cmd)) ||
 958             (!cmd->cmd_startswith && strcmp(cmd->cmd, data))) {
 959             continue;
 960         }
 961
 962         if (cmd->schema) {
 963             if (cmd_parse_params(&data[strlen(cmd->cmd)],
 964                                  cmd->schema, params)) {
 965                 return false;
 966             }
 967         }
 968
 969         if (cmd->need_cpu_context) {
 970             user_ctx = (void *)gdbserver_state.g_cpu;
 971         }
 972
 973         gdbserver_state.allow_stop_reply = cmd->allow_stop_reply;
 974         cmd->handler(params, user_ctx);
 975         return true;
 976     }
 977
 978     return false;
 979 }
 980
 981 static void run_cmd_parser(const char *data, const GdbCmdParseEntry *cmd)
 982 {
 983     if (!data) {
 984         return;
 985     }
 986
 987     g_string_set_size(gdbserver_state.str_buf, 0);
 988     g_byte_array_set_size(gdbserver_state.mem_buf, 0);
 989
 990     /* In case there was an error during the command parsing we must
 991     * send a NULL packet to indicate the command is not supported */
 992     if (!process_string_cmd(data, cmd, 1)) {
 993         gdb_put_packet("");
 994     }
 995 }
 996
 997 static void handle_detach(GArray *params, void *user_ctx)
 998 {
 999     GDBProcess *process;
1000     uint32_t pid = 1;
1001
1002     if (gdbserver_state.multiprocess) {
1003         if (!params->len) {
1004             gdb_put_packet("E22");
1005             return;
1006         }
1007
1008         pid = gdb_get_cmd_param(params, 0)->val_ul;
1009     }
1010
1011 #ifdef CONFIG_USER_ONLY
1012     if (gdb_handle_detach_user(pid)) {
1013         return;
1014     }
1015 #endif
1016
1017     process = gdb_get_process(pid);
1018     gdb_process_breakpoint_remove_all(process);
1019     process->attached = false;
1020
1021     if (pid == gdb_get_cpu_pid(gdbserver_state.c_cpu)) {
1022         gdbserver_state.c_cpu = gdb_first_attached_cpu();
1023     }
1024
1025     if (pid == gdb_get_cpu_pid(gdbserver_state.g_cpu)) {
1026         gdbserver_state.g_cpu = gdb_first_attached_cpu();
1027     }
1028
1029     if (!gdbserver_state.c_cpu) {
1030         /* No more process attached */
1031         gdb_disable_syscalls();
1032         gdb_continue();
1033     }
1034     gdb_put_packet("OK");
1035 }
1036
1037 static void handle_thread_alive(GArray *params, void *user_ctx)
1038 {
1039     CPUState *cpu;
1040
1041     if (!params->len) {
1042         gdb_put_packet("E22");
1043         return;
1044     }
1045
1046     if (gdb_get_cmd_param(params, 0)->thread_id.kind == GDB_READ_THREAD_ERR) {
1047         gdb_put_packet("E22");
1048         return;
1049     }
1050
1051     cpu = gdb_get_cpu(gdb_get_cmd_param(params, 0)->thread_id.pid,
1052                       gdb_get_cmd_param(params, 0)->thread_id.tid);
1053     if (!cpu) {
1054         gdb_put_packet("E22");
1055         return;
1056     }
1057
1058     gdb_put_packet("OK");
1059 }
1060
1061 static void handle_continue(GArray *params, void *user_ctx)
1062 {
1063     if (params->len) {
1064         gdb_set_cpu_pc(gdb_get_cmd_param(params, 0)->val_ull);
1065     }
1066
1067     gdbserver_state.signal = 0;
1068     gdb_continue();
1069 }
1070
1071 static void handle_cont_with_sig(GArray *params, void *user_ctx)
1072 {
1073     unsigned long signal = 0;
1074
1075     /*
1076      * Note: C sig;[addr] is currently unsupported and we simply
1077      *       omit the addr parameter
1078      */
1079     if (params->len) {
1080         signal = gdb_get_cmd_param(params, 0)->val_ul;
1081     }
1082
1083     gdbserver_state.signal = gdb_signal_to_target(signal);
1084     if (gdbserver_state.signal == -1) {
1085         gdbserver_state.signal = 0;
1086     }
1087     gdb_continue();
1088 }
1089
1090 static void handle_set_thread(GArray *params, void *user_ctx)
1091 {
1092     uint32_t pid, tid;
1093     CPUState *cpu;
1094
1095     if (params->len != 2) {
1096         gdb_put_packet("E22");
1097         return;
1098     }
1099
1100     if (gdb_get_cmd_param(params, 1)->thread_id.kind == GDB_READ_THREAD_ERR) {
1101         gdb_put_packet("E22");
1102         return;
1103     }
1104
1105     if (gdb_get_cmd_param(params, 1)->thread_id.kind != GDB_ONE_THREAD) {
1106         gdb_put_packet("OK");
1107         return;
1108     }
1109
1110     pid = gdb_get_cmd_param(params, 1)->thread_id.pid;
1111     tid = gdb_get_cmd_param(params, 1)->thread_id.tid;
1112 #ifdef CONFIG_USER_ONLY
1113     if (gdb_handle_set_thread_user(pid, tid)) {
1114         return;
1115     }
1116 #endif
1117     cpu = gdb_get_cpu(pid, tid);
1118     if (!cpu) {
1119         gdb_put_packet("E22");
1120         return;
1121     }
1122
1123     /*
1124      * Note: This command is deprecated and modern gdb's will be using the
1125      *       vCont command instead.
1126      */
1127     switch (gdb_get_cmd_param(params, 0)->opcode) {
1128     case 'c':
1129         gdbserver_state.c_cpu = cpu;
1130         gdb_put_packet("OK");
1131         break;
1132     case 'g':
1133         gdbserver_state.g_cpu = cpu;
1134         gdb_put_packet("OK");
1135         break;
1136     default:
1137         gdb_put_packet("E22");
1138         break;
1139     }
1140 }
1141
1142 static void handle_insert_bp(GArray *params, void *user_ctx)
1143 {
1144     int res;
1145
1146     if (params->len != 3) {
1147         gdb_put_packet("E22");
1148         return;
1149     }
1150
1151     res = gdb_breakpoint_insert(gdbserver_state.c_cpu,
1152                                 gdb_get_cmd_param(params, 0)->val_ul,
1153                                 gdb_get_cmd_param(params, 1)->val_ull,
1154                                 gdb_get_cmd_param(params, 2)->val_ull);
1155     if (res >= 0) {
1156         gdb_put_packet("OK");
1157         return;
1158     } else if (res == -ENOSYS) {
1159         gdb_put_packet("");
1160         return;
1161     }
1162
1163     gdb_put_packet("E22");
1164 }
1165
1166 static void handle_remove_bp(GArray *params, void *user_ctx)
1167 {
1168     int res;
1169
1170     if (params->len != 3) {
1171         gdb_put_packet("E22");
1172         return;
1173     }
1174
1175     res = gdb_breakpoint_remove(gdbserver_state.c_cpu,
1176                                 gdb_get_cmd_param(params, 0)->val_ul,
1177                                 gdb_get_cmd_param(params, 1)->val_ull,
1178                                 gdb_get_cmd_param(params, 2)->val_ull);
1179     if (res >= 0) {
1180         gdb_put_packet("OK");
1181         return;
1182     } else if (res == -ENOSYS) {
1183         gdb_put_packet("");
1184         return;
1185     }
1186
1187     gdb_put_packet("E22");
1188 }
1189
1190 /*
1191  * handle_set/get_reg
1192  *
1193  * Older gdb are really dumb, and don't use 'G/g' if 'P/p' is available.
1194  * This works, but can be very slow. Anything new enough to understand
1195  * XML also knows how to use this properly. However to use this we
1196  * need to define a local XML file as well as be talking to a
1197  * reasonably modern gdb. Responding with an empty packet will cause
1198  * the remote gdb to fallback to older methods.
1199  */
1200
1201 static void handle_set_reg(GArray *params, void *user_ctx)
1202 {
1203     int reg_size;
1204
1205     if (params->len != 2) {
1206         gdb_put_packet("E22");
1207         return;
1208     }
1209
1210     reg_size = strlen(gdb_get_cmd_param(params, 1)->data) / 2;
1211     gdb_hextomem(gdbserver_state.mem_buf, gdb_get_cmd_param(params, 1)->data, reg_size);
1212     gdb_write_register(gdbserver_state.g_cpu, gdbserver_state.mem_buf->data,
1213                        gdb_get_cmd_param(params, 0)->val_ull);
1214     gdb_put_packet("OK");
1215 }
1216
1217 static void handle_get_reg(GArray *params, void *user_ctx)
1218 {
1219     int reg_size;
1220
1221     if (!params->len) {
1222         gdb_put_packet("E14");
1223         return;
1224     }
1225
1226     reg_size = gdb_read_register(gdbserver_state.g_cpu,
1227                                  gdbserver_state.mem_buf,
1228                                  gdb_get_cmd_param(params, 0)->val_ull);
1229     if (!reg_size) {
1230         gdb_put_packet("E14");
1231         return;
1232     } else {
1233         g_byte_array_set_size(gdbserver_state.mem_buf, reg_size);
1234     }
1235
1236     gdb_memtohex(gdbserver_state.str_buf,
1237                  gdbserver_state.mem_buf->data, reg_size);
1238     gdb_put_strbuf();
1239 }
1240
1241 static void handle_write_mem(GArray *params, void *user_ctx)
1242 {
1243     if (params->len != 3) {
1244         gdb_put_packet("E22");
1245         return;
1246     }
1247
1248     /* gdb_hextomem() reads 2*len bytes */
1249     if (gdb_get_cmd_param(params, 1)->val_ull >
1250         strlen(gdb_get_cmd_param(params, 2)->data) / 2) {
1251         gdb_put_packet("E22");
1252         return;
1253     }
1254
1255     gdb_hextomem(gdbserver_state.mem_buf, gdb_get_cmd_param(params, 2)->data,
1256                  gdb_get_cmd_param(params, 1)->val_ull);
1257     if (gdb_target_memory_rw_debug(gdbserver_state.g_cpu,
1258                                    gdb_get_cmd_param(params, 0)->val_ull,
1259                                    gdbserver_state.mem_buf->data,
1260                                    gdbserver_state.mem_buf->len, true)) {
1261         gdb_put_packet("E14");
1262         return;
1263     }
1264
1265     gdb_put_packet("OK");
1266 }
1267
1268 static void handle_read_mem(GArray *params, void *user_ctx)
1269 {
1270     if (params->len != 2) {
1271         gdb_put_packet("E22");
1272         return;
1273     }
1274
1275     /* gdb_memtohex() doubles the required space */
1276     if (gdb_get_cmd_param(params, 1)->val_ull > MAX_PACKET_LENGTH / 2) {
1277         gdb_put_packet("E22");
1278         return;
1279     }
1280
1281     g_byte_array_set_size(gdbserver_state.mem_buf,
1282                           gdb_get_cmd_param(params, 1)->val_ull);
1283
1284     if (gdb_target_memory_rw_debug(gdbserver_state.g_cpu,
1285                                    gdb_get_cmd_param(params, 0)->val_ull,
1286                                    gdbserver_state.mem_buf->data,
1287                                    gdbserver_state.mem_buf->len, false)) {
1288         gdb_put_packet("E14");
1289         return;
1290     }
1291
1292     gdb_memtohex(gdbserver_state.str_buf, gdbserver_state.mem_buf->data,
1293              gdbserver_state.mem_buf->len);
1294     gdb_put_strbuf();
1295 }
1296
1297 static void handle_write_all_regs(GArray *params, void *user_ctx)
1298 {
1299     int reg_id;
1300     size_t len;
1301     uint8_t *registers;
1302     int reg_size;
1303
1304     if (!params->len) {
1305         return;
1306     }
1307
1308     cpu_synchronize_state(gdbserver_state.g_cpu);
1309     len = strlen(gdb_get_cmd_param(params, 0)->data) / 2;
1310     gdb_hextomem(gdbserver_state.mem_buf, gdb_get_cmd_param(params, 0)->data, len);
1311     registers = gdbserver_state.mem_buf->data;
1312     for (reg_id = 0;
1313          reg_id < gdbserver_state.g_cpu->gdb_num_g_regs && len > 0;
1314          reg_id++) {
1315         reg_size = gdb_write_register(gdbserver_state.g_cpu, registers, reg_id);
1316         len -= reg_size;
1317         registers += reg_size;
1318     }
1319     gdb_put_packet("OK");
1320 }
1321
1322 static void handle_read_all_regs(GArray *params, void *user_ctx)
1323 {
1324     int reg_id;
1325     size_t len;
1326
1327     cpu_synchronize_state(gdbserver_state.g_cpu);
1328     g_byte_array_set_size(gdbserver_state.mem_buf, 0);
1329     len = 0;
1330     for (reg_id = 0; reg_id < gdbserver_state.g_cpu->gdb_num_g_regs; reg_id++) {
1331         len += gdb_read_register(gdbserver_state.g_cpu,
1332                                  gdbserver_state.mem_buf,
1333                                  reg_id);
1334     }
1335     g_assert(len == gdbserver_state.mem_buf->len);
1336
1337     gdb_memtohex(gdbserver_state.str_buf, gdbserver_state.mem_buf->data, len);
1338     gdb_put_strbuf();
1339 }
1340
1341
1342 static void handle_step(GArray *params, void *user_ctx)
1343 {
1344     if (params->len) {
1345         gdb_set_cpu_pc(gdb_get_cmd_param(params, 0)->val_ull);
1346     }
1347
1348     cpu_single_step(gdbserver_state.c_cpu, gdbserver_state.sstep_flags);
1349     gdb_continue();
1350 }
1351
1352 static void handle_backward(GArray *params, void *user_ctx)
1353 {
1354     if (!gdb_can_reverse()) {
1355         gdb_put_packet("E22");
1356     }
1357     if (params->len == 1) {
1358         switch (gdb_get_cmd_param(params, 0)->opcode) {
1359         case 's':
1360             if (replay_reverse_step()) {
1361                 gdb_continue();
1362             } else {
1363                 gdb_put_packet("E14");
1364             }
1365             return;
1366         case 'c':
1367             if (replay_reverse_continue()) {
1368                 gdb_continue();
1369             } else {
1370                 gdb_put_packet("E14");
1371             }
1372             return;
1373         }
1374     }
1375
1376     /* Default invalid command */
1377     gdb_put_packet("");
1378 }
1379
1380 static void handle_v_cont_query(GArray *params, void *user_ctx)
1381 {
1382     gdb_put_packet("vCont;c;C;s;S");
1383 }
1384
1385 static void handle_v_cont(GArray *params, void *user_ctx)
1386 {
1387     int res;
1388
1389     if (!params->len) {
1390         return;
1391     }
1392
1393     res = gdb_handle_vcont(gdb_get_cmd_param(params, 0)->data);
1394     if ((res == -EINVAL) || (res == -ERANGE)) {
1395         gdb_put_packet("E22");
1396     } else if (res) {
1397         gdb_put_packet("");
1398     }
1399 }
1400
1401 static void handle_v_attach(GArray *params, void *user_ctx)
1402 {
1403     GDBProcess *process;
1404     CPUState *cpu;
1405
1406     g_string_assign(gdbserver_state.str_buf, "E22");
1407     if (!params->len) {
1408         goto cleanup;
1409     }
1410
1411     process = gdb_get_process(gdb_get_cmd_param(params, 0)->val_ul);
1412     if (!process) {
1413         goto cleanup;
1414     }
1415
1416     cpu = gdb_get_first_cpu_in_process(process);
1417     if (!cpu) {
1418         goto cleanup;
1419     }
1420
1421     process->attached = true;
1422     gdbserver_state.g_cpu = cpu;
1423     gdbserver_state.c_cpu = cpu;
1424
1425     if (gdbserver_state.allow_stop_reply) {
1426         g_string_printf(gdbserver_state.str_buf, "T%02xthread:", GDB_SIGNAL_TRAP);
1427         gdb_append_thread_id(cpu, gdbserver_state.str_buf);
1428         g_string_append_c(gdbserver_state.str_buf, ';');
1429         gdbserver_state.allow_stop_reply = false;
1430 cleanup:
1431         gdb_put_strbuf();
1432     }
1433 }
1434
1435 static void handle_v_kill(GArray *params, void *user_ctx)
1436 {
1437     /* Kill the target */
1438     gdb_put_packet("OK");
1439     error_report("QEMU: Terminated via GDBstub");
1440     gdb_exit(0);
1441     gdb_qemu_exit(0);
1442 }
1443
1444 static const GdbCmdParseEntry gdb_v_commands_table[] = {
1445     /* Order is important if has same prefix */
1446     {
1447         .handler = handle_v_cont_query,
1448         .cmd = "Cont?",
1449         .cmd_startswith = true
1450     },
1451     {
1452         .handler = handle_v_cont,
1453         .cmd = "Cont",
1454         .cmd_startswith = true,
1455         .allow_stop_reply = true,
1456         .schema = "s0"
1457     },
1458     {
1459         .handler = handle_v_attach,
1460         .cmd = "Attach;",
1461         .cmd_startswith = true,
1462         .allow_stop_reply = true,
1463         .schema = "l0"
1464     },
1465     {
1466         .handler = handle_v_kill,
1467         .cmd = "Kill;",
1468         .cmd_startswith = true
1469     },
1470 #ifdef CONFIG_USER_ONLY
1471     /*
1472      * Host I/O Packets. See [1] for details.
1473      * [1] https://sourceware.org/gdb/onlinedocs/gdb/Host-I_002fO-Packets.html
1474      */
1475     {
1476         .handler = gdb_handle_v_file_open,
1477         .cmd = "File:open:",
1478         .cmd_startswith = true,
1479         .schema = "s,L,L0"
1480     },
1481     {
1482         .handler = gdb_handle_v_file_close,
1483         .cmd = "File:close:",
1484         .cmd_startswith = true,
1485         .schema = "l0"
1486     },
1487     {
1488         .handler = gdb_handle_v_file_pread,
1489         .cmd = "File:pread:",
1490         .cmd_startswith = true,
1491         .schema = "l,L,L0"
1492     },
1493     {
1494         .handler = gdb_handle_v_file_readlink,
1495         .cmd = "File:readlink:",
1496         .cmd_startswith = true,
1497         .schema = "s0"
1498     },
1499 #endif
1500 };
1501
1502 static void handle_v_commands(GArray *params, void *user_ctx)
1503 {
1504     if (!params->len) {
1505         return;
1506     }
1507
1508     if (!process_string_cmd(gdb_get_cmd_param(params, 0)->data,
1509                             gdb_v_commands_table,
1510                             ARRAY_SIZE(gdb_v_commands_table))) {
1511         gdb_put_packet("");
1512     }
1513 }
1514
1515 static void handle_query_qemu_sstepbits(GArray *params, void *user_ctx)
1516 {
1517     g_string_printf(gdbserver_state.str_buf, "ENABLE=%x", SSTEP_ENABLE);
1518
1519     if (gdbserver_state.supported_sstep_flags & SSTEP_NOIRQ) {
1520         g_string_append_printf(gdbserver_state.str_buf, ",NOIRQ=%x",
1521                                SSTEP_NOIRQ);
1522     }
1523
1524     if (gdbserver_state.supported_sstep_flags & SSTEP_NOTIMER) {
1525         g_string_append_printf(gdbserver_state.str_buf, ",NOTIMER=%x",
1526                                SSTEP_NOTIMER);
1527     }
1528
1529     gdb_put_strbuf();
1530 }
1531
1532 static void handle_set_qemu_sstep(GArray *params, void *user_ctx)
1533 {
1534     int new_sstep_flags;
1535
1536     if (!params->len) {
1537         return;
1538     }
1539
1540     new_sstep_flags = gdb_get_cmd_param(params, 0)->val_ul;
1541
1542     if (new_sstep_flags  & ~gdbserver_state.supported_sstep_flags) {
1543         gdb_put_packet("E22");
1544         return;
1545     }
1546
1547     gdbserver_state.sstep_flags = new_sstep_flags;
1548     gdb_put_packet("OK");
1549 }
1550
1551 static void handle_query_qemu_sstep(GArray *params, void *user_ctx)
1552 {
1553     g_string_printf(gdbserver_state.str_buf, "0x%x",
1554                     gdbserver_state.sstep_flags);
1555     gdb_put_strbuf();
1556 }
1557
1558 static void handle_query_curr_tid(GArray *params, void *user_ctx)
1559 {
1560     CPUState *cpu;
1561     GDBProcess *process;
1562
1563     /*
1564      * "Current thread" remains vague in the spec, so always return
1565      * the first thread of the current process (gdb returns the
1566      * first thread).
1567      */
1568     process = gdb_get_cpu_process(gdbserver_state.g_cpu);
1569     cpu = gdb_get_first_cpu_in_process(process);
1570     g_string_assign(gdbserver_state.str_buf, "QC");
1571     gdb_append_thread_id(cpu, gdbserver_state.str_buf);
1572     gdb_put_strbuf();
1573 }
1574
1575 static void handle_query_threads(GArray *params, void *user_ctx)
1576 {
1577     if (!gdbserver_state.query_cpu) {
1578         gdb_put_packet("l");
1579         return;
1580     }
1581
1582     g_string_assign(gdbserver_state.str_buf, "m");
1583     gdb_append_thread_id(gdbserver_state.query_cpu, gdbserver_state.str_buf);
1584     gdb_put_strbuf();
1585     gdbserver_state.query_cpu = gdb_next_attached_cpu(gdbserver_state.query_cpu);
1586 }
1587
1588 static void handle_query_first_threads(GArray *params, void *user_ctx)
1589 {
1590     gdbserver_state.query_cpu = gdb_first_attached_cpu();
1591     handle_query_threads(params, user_ctx);
1592 }
1593
1594 static void handle_query_thread_extra(GArray *params, void *user_ctx)
1595 {
1596     g_autoptr(GString) rs = g_string_new(NULL);
1597     CPUState *cpu;
1598
1599     if (!params->len ||
1600         gdb_get_cmd_param(params, 0)->thread_id.kind == GDB_READ_THREAD_ERR) {
1601         gdb_put_packet("E22");
1602         return;
1603     }
1604
1605     cpu = gdb_get_cpu(gdb_get_cmd_param(params, 0)->thread_id.pid,
1606                       gdb_get_cmd_param(params, 0)->thread_id.tid);
1607     if (!cpu) {
1608         return;
1609     }
1610
1611     cpu_synchronize_state(cpu);
1612
1613     if (gdbserver_state.multiprocess && (gdbserver_state.process_num > 1)) {
1614         /* Print the CPU model and name in multiprocess mode */
1615         ObjectClass *oc = object_get_class(OBJECT(cpu));
1616         const char *cpu_model = object_class_get_name(oc);
1617         const char *cpu_name =
1618             object_get_canonical_path_component(OBJECT(cpu));
1619         g_string_printf(rs, "%s %s [%s]", cpu_model, cpu_name,
1620                         cpu->halted ? "halted " : "running");
1621     } else {
1622         g_string_printf(rs, "CPU#%d [%s]", cpu->cpu_index,
1623                         cpu->halted ? "halted " : "running");
1624     }
1625     trace_gdbstub_op_extra_info(rs->str);
1626     gdb_memtohex(gdbserver_state.str_buf, (uint8_t *)rs->str, rs->len);
1627     gdb_put_strbuf();
1628 }
1629
1630
1631 static char **extra_query_flags;
1632
1633 void gdb_extend_qsupported_features(char *qflags)
1634 {
1635     if (!extra_query_flags) {
1636         extra_query_flags = g_new0(char *, 2);
1637         extra_query_flags[0] = g_strdup(qflags);
1638     } else if (!g_strv_contains((const gchar * const *) extra_query_flags,
1639                                 qflags)) {
1640         int len = g_strv_length(extra_query_flags);
1641         extra_query_flags = g_realloc_n(extra_query_flags, len + 2,
1642                                         sizeof(char *));
1643         extra_query_flags[len] = g_strdup(qflags);
1644     }
1645 }
1646
1647 static void handle_query_supported(GArray *params, void *user_ctx)
1648 {
1649     CPUClass *cc;
1650
1651     g_string_printf(gdbserver_state.str_buf, "PacketSize=%x", MAX_PACKET_LENGTH);
1652     cc = CPU_GET_CLASS(first_cpu);
1653     if (cc->gdb_core_xml_file) {
1654         g_string_append(gdbserver_state.str_buf, ";qXfer:features:read+");
1655     }
1656
1657     if (gdb_can_reverse()) {
1658         g_string_append(gdbserver_state.str_buf,
1659             ";ReverseStep+;ReverseContinue+");
1660     }
1661
1662 #if defined(CONFIG_USER_ONLY)
1663 #if defined(CONFIG_LINUX)
1664     if (get_task_state(gdbserver_state.c_cpu)) {
1665         g_string_append(gdbserver_state.str_buf, ";qXfer:auxv:read+");
1666     }
1667     g_string_append(gdbserver_state.str_buf, ";QCatchSyscalls+");
1668
1669     g_string_append(gdbserver_state.str_buf, ";qXfer:siginfo:read+");
1670 #endif
1671     g_string_append(gdbserver_state.str_buf, ";qXfer:exec-file:read+");
1672 #endif
1673
1674     if (params->len) {
1675         const char *gdb_supported = gdb_get_cmd_param(params, 0)->data;
1676
1677         if (strstr(gdb_supported, "multiprocess+")) {
1678             gdbserver_state.multiprocess = true;
1679         }
1680 #if defined(CONFIG_USER_ONLY)
1681         gdb_handle_query_supported_user(gdb_supported);
1682 #endif
1683     }
1684
1685     g_string_append(gdbserver_state.str_buf, ";vContSupported+;multiprocess+");
1686
1687     if (extra_query_flags) {
1688         int extras = g_strv_length(extra_query_flags);
1689         for (int i = 0; i < extras; i++) {
1690             g_string_append(gdbserver_state.str_buf, extra_query_flags[i]);
1691         }
1692     }
1693
1694     gdb_put_strbuf();
1695 }
1696
1697 static void handle_query_xfer_features(GArray *params, void *user_ctx)
1698 {
1699     GDBProcess *process;
1700     CPUClass *cc;
1701     unsigned long len, total_len, addr;
1702     const char *xml;
1703     const char *p;
1704
1705     if (params->len < 3) {
1706         gdb_put_packet("E22");
1707         return;
1708     }
1709
1710     process = gdb_get_cpu_process(gdbserver_state.g_cpu);
1711     cc = CPU_GET_CLASS(gdbserver_state.g_cpu);
1712     if (!cc->gdb_core_xml_file) {
1713         gdb_put_packet("");
1714         return;
1715     }
1716
1717     p = gdb_get_cmd_param(params, 0)->data;
1718     xml = get_feature_xml(p, &p, process);
1719     if (!xml) {
1720         gdb_put_packet("E00");
1721         return;
1722     }
1723
1724     addr = gdb_get_cmd_param(params, 1)->val_ul;
1725     len = gdb_get_cmd_param(params, 2)->val_ul;
1726     total_len = strlen(xml);
1727     if (addr > total_len) {
1728         gdb_put_packet("E00");
1729         return;
1730     }
1731
1732     if (len > (MAX_PACKET_LENGTH - 5) / 2) {
1733         len = (MAX_PACKET_LENGTH - 5) / 2;
1734     }
1735
1736     if (len < total_len - addr) {
1737         g_string_assign(gdbserver_state.str_buf, "m");
1738         gdb_memtox(gdbserver_state.str_buf, xml + addr, len);
1739     } else {
1740         g_string_assign(gdbserver_state.str_buf, "l");
1741         gdb_memtox(gdbserver_state.str_buf, xml + addr, total_len - addr);
1742     }
1743
1744     gdb_put_packet_binary(gdbserver_state.str_buf->str,
1745                       gdbserver_state.str_buf->len, true);
1746 }
1747
1748 static void handle_query_qemu_supported(GArray *params, void *user_ctx)
1749 {
1750     g_string_printf(gdbserver_state.str_buf, "sstepbits;sstep");
1751 #ifndef CONFIG_USER_ONLY
1752     g_string_append(gdbserver_state.str_buf, ";PhyMemMode");
1753 #endif
1754     gdb_put_strbuf();
1755 }
1756
1757 static const GdbCmdParseEntry gdb_gen_query_set_common_table[] = {
1758     /* Order is important if has same prefix */
1759     {
1760         .handler = handle_query_qemu_sstepbits,
1761         .cmd = "qemu.sstepbits",
1762     },
1763     {
1764         .handler = handle_query_qemu_sstep,
1765         .cmd = "qemu.sstep",
1766     },
1767     {
1768         .handler = handle_set_qemu_sstep,
1769         .cmd = "qemu.sstep=",
1770         .cmd_startswith = true,
1771         .schema = "l0"
1772     },
1773 };
1774
1775 /**
1776  * extend_table() - extend one of the command tables
1777  * @table: the command table to extend (or NULL)
1778  * @extensions: a list of GdbCmdParseEntry pointers
1779  *
1780  * The entries themselves should be pointers to static const
1781  * GdbCmdParseEntry entries. If the entry is already in the table we
1782  * skip adding it again.
1783  *
1784  * Returns (a potentially freshly allocated) GPtrArray of GdbCmdParseEntry
1785  */
1786 static GPtrArray *extend_table(GPtrArray *table, GPtrArray *extensions)
1787 {
1788     if (!table) {
1789         table = g_ptr_array_new();
1790     }
1791
1792     for (int i = 0; i < extensions->len; i++) {
1793         gpointer entry = g_ptr_array_index(extensions, i);
1794         if (!g_ptr_array_find(table, entry, NULL)) {
1795             g_ptr_array_add(table, entry);
1796         }
1797     }
1798
1799     return table;
1800 }
1801
1802 /**
1803  * process_extended_table() - run through an extended command table
1804  * @table: the command table to check
1805  * @data: parameters
1806  *
1807  * returns true if the command was found and executed
1808  */
1809 static bool process_extended_table(GPtrArray *table, const char *data)
1810 {
1811     for (int i = 0; i < table->len; i++) {
1812         const GdbCmdParseEntry *entry = g_ptr_array_index(table, i);
1813         if (process_string_cmd(data, entry, 1)) {
1814             return true;
1815         }
1816     }
1817     return false;
1818 }
1819
1820
1821 /* Ptr to GdbCmdParseEntry */
1822 static GPtrArray *extended_query_table;
1823
1824 void gdb_extend_query_table(GPtrArray *new_queries)
1825 {
1826     extended_query_table = extend_table(extended_query_table, new_queries);
1827 }
1828
1829 static const GdbCmdParseEntry gdb_gen_query_table[] = {
1830     {
1831         .handler = handle_query_curr_tid,
1832         .cmd = "C",
1833     },
1834     {
1835         .handler = handle_query_threads,
1836         .cmd = "sThreadInfo",
1837     },
1838     {
1839         .handler = handle_query_first_threads,
1840         .cmd = "fThreadInfo",
1841     },
1842     {
1843         .handler = handle_query_thread_extra,
1844         .cmd = "ThreadExtraInfo,",
1845         .cmd_startswith = true,
1846         .schema = "t0"
1847     },
1848 #ifdef CONFIG_USER_ONLY
1849     {
1850         .handler = gdb_handle_query_offsets,
1851         .cmd = "Offsets",
1852     },
1853 #else
1854     {
1855         .handler = gdb_handle_query_rcmd,
1856         .cmd = "Rcmd,",
1857         .cmd_startswith = true,
1858         .schema = "s0"
1859     },
1860 #endif
1861     {
1862         .handler = handle_query_supported,
1863         .cmd = "Supported:",
1864         .cmd_startswith = true,
1865         .schema = "s0"
1866     },
1867     {
1868         .handler = handle_query_supported,
1869         .cmd = "Supported",
1870         .schema = "s0"
1871     },
1872     {
1873         .handler = handle_query_xfer_features,
1874         .cmd = "Xfer:features:read:",
1875         .cmd_startswith = true,
1876         .schema = "s:l,l0"
1877     },
1878 #if defined(CONFIG_USER_ONLY)
1879 #if defined(CONFIG_LINUX)
1880     {
1881         .handler = gdb_handle_query_xfer_auxv,
1882         .cmd = "Xfer:auxv:read::",
1883         .cmd_startswith = true,
1884         .schema = "l,l0"
1885     },
1886     {
1887         .handler = gdb_handle_query_xfer_siginfo,
1888         .cmd = "Xfer:siginfo:read::",
1889         .cmd_startswith = true,
1890         .schema = "l,l0"
1891      },
1892 #endif
1893     {
1894         .handler = gdb_handle_query_xfer_exec_file,
1895         .cmd = "Xfer:exec-file:read:",
1896         .cmd_startswith = true,
1897         .schema = "l:l,l0"
1898     },
1899 #endif
1900     {
1901         .handler = gdb_handle_query_attached,
1902         .cmd = "Attached:",
1903         .cmd_startswith = true
1904     },
1905     {
1906         .handler = gdb_handle_query_attached,
1907         .cmd = "Attached",
1908     },
1909     {
1910         .handler = handle_query_qemu_supported,
1911         .cmd = "qemu.Supported",
1912     },
1913 #ifndef CONFIG_USER_ONLY
1914     {
1915         .handler = gdb_handle_query_qemu_phy_mem_mode,
1916         .cmd = "qemu.PhyMemMode",
1917     },
1918 #endif
1919 };
1920
1921 /* Ptr to GdbCmdParseEntry */
1922 static GPtrArray *extended_set_table;
1923
1924 void gdb_extend_set_table(GPtrArray *new_set)
1925 {
1926     extended_set_table = extend_table(extended_set_table, new_set);
1927 }
1928
1929 static const GdbCmdParseEntry gdb_gen_set_table[] = {
1930     /* Order is important if has same prefix */
1931     {
1932         .handler = handle_set_qemu_sstep,
1933         .cmd = "qemu.sstep:",
1934         .cmd_startswith = true,
1935         .schema = "l0"
1936     },
1937 #ifndef CONFIG_USER_ONLY
1938     {
1939         .handler = gdb_handle_set_qemu_phy_mem_mode,
1940         .cmd = "qemu.PhyMemMode:",
1941         .cmd_startswith = true,
1942         .schema = "l0"
1943     },
1944 #endif
1945 #if defined(CONFIG_USER_ONLY)
1946     {
1947         .handler = gdb_handle_set_catch_syscalls,
1948         .cmd = "CatchSyscalls:",
1949         .cmd_startswith = true,
1950         .schema = "s0",
1951     },
1952 #endif
1953 };
1954
1955 static void handle_gen_query(GArray *params, void *user_ctx)
1956 {
1957     const char *data;
1958
1959     if (!params->len) {
1960         return;
1961     }
1962
1963     data = gdb_get_cmd_param(params, 0)->data;
1964
1965     if (process_string_cmd(data,
1966                            gdb_gen_query_set_common_table,
1967                            ARRAY_SIZE(gdb_gen_query_set_common_table))) {
1968         return;
1969     }
1970
1971     if (process_string_cmd(data,
1972                            gdb_gen_query_table,
1973                            ARRAY_SIZE(gdb_gen_query_table))) {
1974         return;
1975     }
1976
1977     if (extended_query_table &&
1978         process_extended_table(extended_query_table, data)) {
1979         return;
1980     }
1981
1982     /* Can't handle query, return Empty response. */
1983     gdb_put_packet("");
1984 }
1985
1986 static void handle_gen_set(GArray *params, void *user_ctx)
1987 {
1988     const char *data;
1989
1990     if (!params->len) {
1991         return;
1992     }
1993
1994     data = gdb_get_cmd_param(params, 0)->data;
1995
1996     if (process_string_cmd(data,
1997                            gdb_gen_query_set_common_table,
1998                            ARRAY_SIZE(gdb_gen_query_set_common_table))) {
1999         return;
2000     }
2001
2002     if (process_string_cmd(data,
2003                            gdb_gen_set_table,
2004                            ARRAY_SIZE(gdb_gen_set_table))) {
2005         return;
2006     }
2007
2008     if (extended_set_table &&
2009         process_extended_table(extended_set_table, data)) {
2010         return;
2011     }
2012
2013     /* Can't handle set, return Empty response. */
2014     gdb_put_packet("");
2015 }
2016
2017 static void handle_target_halt(GArray *params, void *user_ctx)
2018 {
2019     if (gdbserver_state.allow_stop_reply) {
2020         g_string_printf(gdbserver_state.str_buf, "T%02xthread:", GDB_SIGNAL_TRAP);
2021         gdb_append_thread_id(gdbserver_state.c_cpu, gdbserver_state.str_buf);
2022         g_string_append_c(gdbserver_state.str_buf, ';');
2023         gdb_put_strbuf();
2024         gdbserver_state.allow_stop_reply = false;
2025     }
2026     /*
2027      * Remove all the breakpoints when this query is issued,
2028      * because gdb is doing an initial connect and the state
2029      * should be cleaned up.
2030      */
2031     gdb_breakpoint_remove_all(gdbserver_state.c_cpu);
2032 }
2033
2034 static int gdb_handle_packet(const char *line_buf)
2035 {
2036     const GdbCmdParseEntry *cmd_parser = NULL;
2037
2038     trace_gdbstub_io_command(line_buf);
2039
2040     switch (line_buf[0]) {
2041     case '!':
2042         gdb_put_packet("OK");
2043         break;
2044     case '?':
2045         {
2046             static const GdbCmdParseEntry target_halted_cmd_desc = {
2047                 .handler = handle_target_halt,
2048                 .cmd = "?",
2049                 .cmd_startswith = true,
2050                 .allow_stop_reply = true,
2051             };
2052             cmd_parser = &target_halted_cmd_desc;
2053         }
2054         break;
2055     case 'c':
2056         {
2057             static const GdbCmdParseEntry continue_cmd_desc = {
2058                 .handler = handle_continue,
2059                 .cmd = "c",
2060                 .cmd_startswith = true,
2061                 .allow_stop_reply = true,
2062                 .schema = "L0"
2063             };
2064             cmd_parser = &continue_cmd_desc;
2065         }
2066         break;
2067     case 'C':
2068         {
2069             static const GdbCmdParseEntry cont_with_sig_cmd_desc = {
2070                 .handler = handle_cont_with_sig,
2071                 .cmd = "C",
2072                 .cmd_startswith = true,
2073                 .allow_stop_reply = true,
2074                 .schema = "l0"
2075             };
2076             cmd_parser = &cont_with_sig_cmd_desc;
2077         }
2078         break;
2079     case 'v':
2080         {
2081             static const GdbCmdParseEntry v_cmd_desc = {
2082                 .handler = handle_v_commands,
2083                 .cmd = "v",
2084                 .cmd_startswith = true,
2085                 .schema = "s0"
2086             };
2087             cmd_parser = &v_cmd_desc;
2088         }
2089         break;
2090     case 'k':
2091         /* Kill the target */
2092         error_report("QEMU: Terminated via GDBstub");
2093         gdb_exit(0);
2094         gdb_qemu_exit(0);
2095         break;
2096     case 'D':
2097         {
2098             static const GdbCmdParseEntry detach_cmd_desc = {
2099                 .handler = handle_detach,
2100                 .cmd = "D",
2101                 .cmd_startswith = true,
2102                 .schema = "?.l0"
2103             };
2104             cmd_parser = &detach_cmd_desc;
2105         }
2106         break;
2107     case 's':
2108         {
2109             static const GdbCmdParseEntry step_cmd_desc = {
2110                 .handler = handle_step,
2111                 .cmd = "s",
2112                 .cmd_startswith = true,
2113                 .allow_stop_reply = true,
2114                 .schema = "L0"
2115             };
2116             cmd_parser = &step_cmd_desc;
2117         }
2118         break;
2119     case 'b':
2120         {
2121             static const GdbCmdParseEntry backward_cmd_desc = {
2122                 .handler = handle_backward,
2123                 .cmd = "b",
2124                 .cmd_startswith = true,
2125                 .allow_stop_reply = true,
2126                 .schema = "o0"
2127             };
2128             cmd_parser = &backward_cmd_desc;
2129         }
2130         break;
2131     case 'F':
2132         {
2133             static const GdbCmdParseEntry file_io_cmd_desc = {
2134                 .handler = gdb_handle_file_io,
2135                 .cmd = "F",
2136                 .cmd_startswith = true,
2137                 .schema = "L,L,o0"
2138             };
2139             cmd_parser = &file_io_cmd_desc;
2140         }
2141         break;
2142     case 'g':
2143         {
2144             static const GdbCmdParseEntry read_all_regs_cmd_desc = {
2145                 .handler = handle_read_all_regs,
2146                 .cmd = "g",
2147                 .cmd_startswith = true
2148             };
2149             cmd_parser = &read_all_regs_cmd_desc;
2150         }
2151         break;
2152     case 'G':
2153         {
2154             static const GdbCmdParseEntry write_all_regs_cmd_desc = {
2155                 .handler = handle_write_all_regs,
2156                 .cmd = "G",
2157                 .cmd_startswith = true,
2158                 .schema = "s0"
2159             };
2160             cmd_parser = &write_all_regs_cmd_desc;
2161         }
2162         break;
2163     case 'm':
2164         {
2165             static const GdbCmdParseEntry read_mem_cmd_desc = {
2166                 .handler = handle_read_mem,
2167                 .cmd = "m",
2168                 .cmd_startswith = true,
2169                 .schema = "L,L0"
2170             };
2171             cmd_parser = &read_mem_cmd_desc;
2172         }
2173         break;
2174     case 'M':
2175         {
2176             static const GdbCmdParseEntry write_mem_cmd_desc = {
2177                 .handler = handle_write_mem,
2178                 .cmd = "M",
2179                 .cmd_startswith = true,
2180                 .schema = "L,L:s0"
2181             };
2182             cmd_parser = &write_mem_cmd_desc;
2183         }
2184         break;
2185     case 'p':
2186         {
2187             static const GdbCmdParseEntry get_reg_cmd_desc = {
2188                 .handler = handle_get_reg,
2189                 .cmd = "p",
2190                 .cmd_startswith = true,
2191                 .schema = "L0"
2192             };
2193             cmd_parser = &get_reg_cmd_desc;
2194         }
2195         break;
2196     case 'P':
2197         {
2198             static const GdbCmdParseEntry set_reg_cmd_desc = {
2199                 .handler = handle_set_reg,
2200                 .cmd = "P",
2201                 .cmd_startswith = true,
2202                 .schema = "L?s0"
2203             };
2204             cmd_parser = &set_reg_cmd_desc;
2205         }
2206         break;
2207     case 'Z':
2208         {
2209             static const GdbCmdParseEntry insert_bp_cmd_desc = {
2210                 .handler = handle_insert_bp,
2211                 .cmd = "Z",
2212                 .cmd_startswith = true,
2213                 .schema = "l?L?L0"
2214             };
2215             cmd_parser = &insert_bp_cmd_desc;
2216         }
2217         break;
2218     case 'z':
2219         {
2220             static const GdbCmdParseEntry remove_bp_cmd_desc = {
2221                 .handler = handle_remove_bp,
2222                 .cmd = "z",
2223                 .cmd_startswith = true,
2224                 .schema = "l?L?L0"
2225             };
2226             cmd_parser = &remove_bp_cmd_desc;
2227         }
2228         break;
2229     case 'H':
2230         {
2231             static const GdbCmdParseEntry set_thread_cmd_desc = {
2232                 .handler = handle_set_thread,
2233                 .cmd = "H",
2234                 .cmd_startswith = true,
2235                 .schema = "o.t0"
2236             };
2237             cmd_parser = &set_thread_cmd_desc;
2238         }
2239         break;
2240     case 'T':
2241         {
2242             static const GdbCmdParseEntry thread_alive_cmd_desc = {
2243                 .handler = handle_thread_alive,
2244                 .cmd = "T",
2245                 .cmd_startswith = true,
2246                 .schema = "t0"
2247             };
2248             cmd_parser = &thread_alive_cmd_desc;
2249         }
2250         break;
2251     case 'q':
2252         {
2253             static const GdbCmdParseEntry gen_query_cmd_desc = {
2254                 .handler = handle_gen_query,
2255                 .cmd = "q",
2256                 .cmd_startswith = true,
2257                 .schema = "s0"
2258             };
2259             cmd_parser = &gen_query_cmd_desc;
2260         }
2261         break;
2262     case 'Q':
2263         {
2264             static const GdbCmdParseEntry gen_set_cmd_desc = {
2265                 .handler = handle_gen_set,
2266                 .cmd = "Q",
2267                 .cmd_startswith = true,
2268                 .schema = "s0"
2269             };
2270             cmd_parser = &gen_set_cmd_desc;
2271         }
2272         break;
2273     default:
2274         /* put empty packet */
2275         gdb_put_packet("");
2276         break;
2277     }
2278
2279     if (cmd_parser) {
2280         run_cmd_parser(line_buf, cmd_parser);
2281     }
2282
2283     return RS_IDLE;
2284 }
2285
2286 void gdb_set_stop_cpu(CPUState *cpu)
2287 {
2288     GDBProcess *p = gdb_get_cpu_process(cpu);
2289
2290     if (!p->attached) {
2291         /*
2292          * Having a stop CPU corresponding to a process that is not attached
2293          * confuses GDB. So we ignore the request.
2294          */
2295         return;
2296     }
2297
2298     gdbserver_state.c_cpu = cpu;
2299     gdbserver_state.g_cpu = cpu;
2300 }
2301
2302 void gdb_read_byte(uint8_t ch)
2303 {
2304     uint8_t reply;
2305
2306     gdbserver_state.allow_stop_reply = false;
2307 #ifndef CONFIG_USER_ONLY
2308     if (gdbserver_state.last_packet->len) {
2309         /* Waiting for a response to the last packet.  If we see the start
2310            of a new command then abandon the previous response.  */
2311         if (ch == '-') {
2312             trace_gdbstub_err_got_nack();
2313             gdb_put_buffer(gdbserver_state.last_packet->data,
2314                        gdbserver_state.last_packet->len);
2315         } else if (ch == '+') {
2316             trace_gdbstub_io_got_ack();
2317         } else {
2318             trace_gdbstub_io_got_unexpected(ch);
2319         }
2320
2321         if (ch == '+' || ch == '$') {
2322             g_byte_array_set_size(gdbserver_state.last_packet, 0);
2323         }
2324         if (ch != '$')
2325             return;
2326     }
2327     if (runstate_is_running()) {
2328         /*
2329          * When the CPU is running, we cannot do anything except stop
2330          * it when receiving a char. This is expected on a Ctrl-C in the
2331          * gdb client. Because we are in all-stop mode, gdb sends a
2332          * 0x03 byte which is not a usual packet, so we handle it specially
2333          * here, but it does expect a stop reply.
2334          */
2335         if (ch != 0x03) {
2336             trace_gdbstub_err_unexpected_runpkt(ch);
2337         } else {
2338             gdbserver_state.allow_stop_reply = true;
2339         }
2340         vm_stop(RUN_STATE_PAUSED);
2341     } else
2342 #endif
2343     {
2344         switch(gdbserver_state.state) {
2345         case RS_IDLE:
2346             if (ch == '$') {
2347                 /* start of command packet */
2348                 gdbserver_state.line_buf_index = 0;
2349                 gdbserver_state.line_sum = 0;
2350                 gdbserver_state.state = RS_GETLINE;
2351             } else if (ch == '+') {
2352                 /*
2353                  * do nothing, gdb may preemptively send out ACKs on
2354                  * initial connection
2355                  */
2356             } else {
2357                 trace_gdbstub_err_garbage(ch);
2358             }
2359             break;
2360         case RS_GETLINE:
2361             if (ch == '}') {
2362                 /* start escape sequence */
2363                 gdbserver_state.state = RS_GETLINE_ESC;
2364                 gdbserver_state.line_sum += ch;
2365             } else if (ch == '*') {
2366                 /* start run length encoding sequence */
2367                 gdbserver_state.state = RS_GETLINE_RLE;
2368                 gdbserver_state.line_sum += ch;
2369             } else if (ch == '#') {
2370                 /* end of command, start of checksum*/
2371                 gdbserver_state.state = RS_CHKSUM1;
2372             } else if (gdbserver_state.line_buf_index >= sizeof(gdbserver_state.line_buf) - 1) {
2373                 trace_gdbstub_err_overrun();
2374                 gdbserver_state.state = RS_IDLE;
2375             } else {
2376                 /* unescaped command character */
2377                 gdbserver_state.line_buf[gdbserver_state.line_buf_index++] = ch;
2378                 gdbserver_state.line_sum += ch;
2379             }
2380             break;
2381         case RS_GETLINE_ESC:
2382             if (ch == '#') {
2383                 /* unexpected end of command in escape sequence */
2384                 gdbserver_state.state = RS_CHKSUM1;
2385             } else if (gdbserver_state.line_buf_index >= sizeof(gdbserver_state.line_buf) - 1) {
2386                 /* command buffer overrun */
2387                 trace_gdbstub_err_overrun();
2388                 gdbserver_state.state = RS_IDLE;
2389             } else {
2390                 /* parse escaped character and leave escape state */
2391                 gdbserver_state.line_buf[gdbserver_state.line_buf_index++] = ch ^ 0x20;
2392                 gdbserver_state.line_sum += ch;
2393                 gdbserver_state.state = RS_GETLINE;
2394             }
2395             break;
2396         case RS_GETLINE_RLE:
2397             /*
2398              * Run-length encoding is explained in "Debugging with GDB /
2399              * Appendix E GDB Remote Serial Protocol / Overview".
2400              */
2401             if (ch < ' ' || ch == '#' || ch == '$' || ch > 126) {
2402                 /* invalid RLE count encoding */
2403                 trace_gdbstub_err_invalid_repeat(ch);
2404                 gdbserver_state.state = RS_GETLINE;
2405             } else {
2406                 /* decode repeat length */
2407                 int repeat = ch - ' ' + 3;
2408                 if (gdbserver_state.line_buf_index + repeat >= sizeof(gdbserver_state.line_buf) - 1) {
2409                     /* that many repeats would overrun the command buffer */
2410                     trace_gdbstub_err_overrun();
2411                     gdbserver_state.state = RS_IDLE;
2412                 } else if (gdbserver_state.line_buf_index < 1) {
2413                     /* got a repeat but we have nothing to repeat */
2414                     trace_gdbstub_err_invalid_rle();
2415                     gdbserver_state.state = RS_GETLINE;
2416                 } else {
2417                     /* repeat the last character */
2418                     memset(gdbserver_state.line_buf + gdbserver_state.line_buf_index,
2419                            gdbserver_state.line_buf[gdbserver_state.line_buf_index - 1], repeat);
2420                     gdbserver_state.line_buf_index += repeat;
2421                     gdbserver_state.line_sum += ch;
2422                     gdbserver_state.state = RS_GETLINE;
2423                 }
2424             }
2425             break;
2426         case RS_CHKSUM1:
2427             /* get high hex digit of checksum */
2428             if (!isxdigit(ch)) {
2429                 trace_gdbstub_err_checksum_invalid(ch);
2430                 gdbserver_state.state = RS_GETLINE;
2431                 break;
2432             }
2433             gdbserver_state.line_buf[gdbserver_state.line_buf_index] = '\0';
2434             gdbserver_state.line_csum = fromhex(ch) << 4;
2435             gdbserver_state.state = RS_CHKSUM2;
2436             break;
2437         case RS_CHKSUM2:
2438             /* get low hex digit of checksum */
2439             if (!isxdigit(ch)) {
2440                 trace_gdbstub_err_checksum_invalid(ch);
2441                 gdbserver_state.state = RS_GETLINE;
2442                 break;
2443             }
2444             gdbserver_state.line_csum |= fromhex(ch);
2445
2446             if (gdbserver_state.line_csum != (gdbserver_state.line_sum & 0xff)) {
2447                 trace_gdbstub_err_checksum_incorrect(gdbserver_state.line_sum, gdbserver_state.line_csum);
2448                 /* send NAK reply */
2449                 reply = '-';
2450                 gdb_put_buffer(&reply, 1);
2451                 gdbserver_state.state = RS_IDLE;
2452             } else {
2453                 /* send ACK reply */
2454                 reply = '+';
2455                 gdb_put_buffer(&reply, 1);
2456                 gdbserver_state.state = gdb_handle_packet(gdbserver_state.line_buf);
2457             }
2458             break;
2459         default:
2460             abort();
2461         }
2462     }
2463 }
2464
2465 /*
2466  * Create the process that will contain all the "orphan" CPUs (that are not
2467  * part of a CPU cluster). Note that if this process contains no CPUs, it won't
2468  * be attachable and thus will be invisible to the user.
2469  */
2470 void gdb_create_default_process(GDBState *s)
2471 {
2472     GDBProcess *process;
2473     int pid;
2474
2475 #ifdef CONFIG_USER_ONLY
2476     assert(gdbserver_state.process_num == 0);
2477     pid = getpid();
2478 #else
2479     if (gdbserver_state.process_num) {
2480         pid = s->processes[s->process_num - 1].pid;
2481     } else {
2482         pid = 0;
2483     }
2484     /* We need an available PID slot for this process */
2485     assert(pid < UINT32_MAX);
2486     pid++;
2487 #endif
2488
2489     s->processes = g_renew(GDBProcess, s->processes, ++s->process_num);
2490     process = &s->processes[s->process_num - 1];
2491     process->pid = pid;
2492     process->attached = false;
2493     process->target_xml = NULL;
2494 }
2495