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