1 /*- 2 * SPDX-License-Identifier: BSD-2-Clause 3 * 4 * Copyright (c) 2004 Marcel Moolenaar 5 * All rights reserved. 6 * 7 * Redistribution and use in source and binary forms, with or without 8 * modification, are permitted provided that the following conditions 9 * are met: 10 * 11 * 1. Redistributions of source code must retain the above copyright 12 * notice, this list of conditions and the following disclaimer. 13 * 2. Redistributions in binary form must reproduce the above copyright 14 * notice, this list of conditions and the following disclaimer in the 15 * documentation and/or other materials provided with the distribution. 16 * 17 * THIS SOFTWARE IS PROVIDED BY THE AUTHORS ``AS IS'' AND ANY EXPRESS OR 18 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES 19 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 20 * IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY DIRECT, INDIRECT, 21 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT 22 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 23 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 24 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 25 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF 26 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 27 */ 28 29 #include <sys/cdefs.h> 30 #include <sys/param.h> 31 #include <sys/systm.h> 32 #include <sys/kdb.h> 33 #include <sys/kernel.h> 34 #include <sys/pcpu.h> 35 #include <sys/proc.h> 36 #include <sys/reboot.h> 37 #include <sys/sbuf.h> 38 39 #include <machine/gdb_machdep.h> 40 #include <machine/kdb.h> 41 42 #include <gdb/gdb.h> 43 #include <gdb/gdb_int.h> 44 45 SYSCTL_NODE(_debug, OID_AUTO, gdb, CTLFLAG_RW | CTLFLAG_MPSAFE, 0, 46 "GDB settings"); 47 48 static dbbe_init_f gdb_init; 49 static dbbe_trap_f gdb_trap; 50 51 KDB_BACKEND(gdb, gdb_init, NULL, NULL, gdb_trap); 52 53 static struct gdb_dbgport null_gdb_dbgport; 54 DATA_SET(gdb_dbgport_set, null_gdb_dbgport); 55 SET_DECLARE(gdb_dbgport_set, struct gdb_dbgport); 56 57 struct gdb_dbgport *gdb_cur = NULL; 58 int gdb_listening = 0; 59 bool gdb_ackmode = true; 60 61 static unsigned char gdb_bindata[64]; 62 63 #ifdef DDB 64 bool gdb_return_to_ddb = false; 65 #endif 66 67 static int 68 gdb_init(void) 69 { 70 struct gdb_dbgport *dp, **iter; 71 int cur_pri, pri; 72 73 gdb_cur = NULL; 74 cur_pri = -1; 75 SET_FOREACH(iter, gdb_dbgport_set) { 76 dp = *iter; 77 pri = (dp->gdb_probe != NULL) ? dp->gdb_probe() : -1; 78 dp->gdb_active = (pri >= 0) ? 0 : -1; 79 if (pri > cur_pri) { 80 cur_pri = pri; 81 gdb_cur = dp; 82 } 83 } 84 if (gdb_cur != NULL) { 85 printf("GDB: debug ports:"); 86 SET_FOREACH(iter, gdb_dbgport_set) { 87 dp = *iter; 88 if (dp->gdb_active == 0) 89 printf(" %s", dp->gdb_name); 90 } 91 printf("\n"); 92 } else 93 printf("GDB: no debug ports present\n"); 94 if (gdb_cur != NULL) { 95 gdb_cur->gdb_init(); 96 printf("GDB: current port: %s\n", gdb_cur->gdb_name); 97 } 98 if (gdb_cur != NULL) { 99 cur_pri = (boothowto & RB_GDB) ? 2 : 0; 100 gdb_consinit(); 101 } else 102 cur_pri = -1; 103 return (cur_pri); 104 } 105 106 static void 107 gdb_do_mem_search(void) 108 { 109 size_t patlen; 110 intmax_t addr, size; 111 const unsigned char *found; 112 113 if (gdb_rx_varhex(&addr) || gdb_rx_char() != ';' || 114 gdb_rx_varhex(&size) || gdb_rx_char() != ';' || 115 gdb_rx_bindata(gdb_bindata, sizeof(gdb_bindata), &patlen)) { 116 gdb_tx_err(EINVAL); 117 return; 118 } 119 if (gdb_search_mem((char *)(uintptr_t)addr, size, gdb_bindata, 120 patlen, &found)) { 121 if (found == 0ULL) 122 gdb_tx_begin('0'); 123 else { 124 gdb_tx_begin('1'); 125 gdb_tx_char(','); 126 gdb_tx_hex((intmax_t)(uintptr_t)found, 8); 127 } 128 gdb_tx_end(); 129 } else 130 gdb_tx_err(EIO); 131 } 132 133 static void 134 gdb_do_threadinfo(struct thread **thr_iter) 135 { 136 static struct thread * const done_sentinel = (void *)(uintptr_t)1; 137 static const size_t tidsz_hex = sizeof(lwpid_t) * 2; 138 size_t tds_sent; 139 140 if (*thr_iter == NULL) { 141 gdb_tx_err(ENXIO); 142 return; 143 } 144 145 if (*thr_iter == done_sentinel) { 146 gdb_tx_begin('l'); 147 *thr_iter = NULL; 148 goto sendit; 149 } 150 151 gdb_tx_begin('m'); 152 153 for (tds_sent = 0; 154 *thr_iter != NULL && gdb_txbuf_has_capacity(tidsz_hex + 1); 155 *thr_iter = kdb_thr_next(*thr_iter), tds_sent++) { 156 if (tds_sent > 0) 157 gdb_tx_char(','); 158 gdb_tx_varhex((*thr_iter)->td_tid); 159 } 160 161 /* 162 * Can't send EOF and "some" in same packet, so set a sentinel to send 163 * EOF when GDB asks us next. 164 */ 165 if (*thr_iter == NULL && tds_sent > 0) 166 *thr_iter = done_sentinel; 167 168 sendit: 169 gdb_tx_end(); 170 } 171 172 #define BIT(n) (1ull << (n)) 173 enum { 174 GDB_MULTIPROCESS, 175 GDB_SWBREAK, 176 GDB_HWBREAK, 177 GDB_QRELOCINSN, 178 GDB_FORK_EVENTS, 179 GDB_VFORK_EVENTS, 180 GDB_EXEC_EVENTS, 181 GDB_VCONT_SUPPORTED, 182 GDB_QTHREADEVENTS, 183 GDB_NO_RESUMED, 184 }; 185 static const char * const gdb_feature_names[] = { 186 [GDB_MULTIPROCESS] = "multiprocess", 187 [GDB_SWBREAK] = "swbreak", 188 [GDB_HWBREAK] = "hwbreak", 189 [GDB_QRELOCINSN] = "qRelocInsn", 190 [GDB_FORK_EVENTS] = "fork-events", 191 [GDB_VFORK_EVENTS] = "vfork-events", 192 [GDB_EXEC_EVENTS] = "exec-events", 193 [GDB_VCONT_SUPPORTED] = "vContSupported", 194 [GDB_QTHREADEVENTS] = "QThreadEvents", 195 [GDB_NO_RESUMED] = "no-resumed", 196 }; 197 static void 198 gdb_do_qsupported(uint32_t *feat) 199 { 200 char *tok, *delim, ok; 201 size_t i, toklen; 202 203 /* Parse supported host features */ 204 *feat = 0; 205 switch (gdb_rx_char()) { 206 case ':': 207 break; 208 case EOF: 209 goto nofeatures; 210 default: 211 goto error; 212 } 213 214 while (gdb_rxsz > 0) { 215 tok = gdb_rxp; 216 delim = strchrnul(gdb_rxp, ';'); 217 toklen = (delim - tok); 218 219 gdb_rxp += toklen; 220 gdb_rxsz -= toklen; 221 if (*delim != '\0') { 222 *delim = '\0'; 223 gdb_rxp += 1; 224 gdb_rxsz -= 1; 225 } 226 227 if (toklen < 2) 228 goto error; 229 230 ok = tok[toklen - 1]; 231 if (ok != '-' && ok != '+') { 232 /* 233 * GDB only has one KV-pair feature, and we don't 234 * support it, so ignore and move on. 235 */ 236 if (strchr(tok, '=') != NULL) 237 continue; 238 /* Not a KV-pair, and not a +/- flag? Malformed. */ 239 goto error; 240 } 241 if (ok != '+') 242 continue; 243 tok[toklen - 1] = '\0'; 244 245 for (i = 0; i < nitems(gdb_feature_names); i++) 246 if (strcmp(gdb_feature_names[i], tok) == 0) 247 break; 248 249 if (i == nitems(gdb_feature_names)) { 250 /* Unknown GDB feature. */ 251 continue; 252 } 253 254 *feat |= BIT(i); 255 } 256 257 nofeatures: 258 /* Send a supported feature list back */ 259 gdb_tx_begin(0); 260 261 gdb_tx_str("PacketSize"); 262 gdb_tx_char('='); 263 /* 264 * We don't buffer framing bytes, but we do need to retain a byte for a 265 * trailing nul. 266 */ 267 gdb_tx_varhex(GDB_BUFSZ + strlen("$#nn") - 1); 268 269 gdb_tx_str(";qXfer:threads:read+"); 270 271 /* 272 * If the debugport is a reliable transport, request No Ack mode from 273 * the server. The server may or may not choose to enter No Ack mode. 274 * https://sourceware.org/gdb/onlinedocs/gdb/Packet-Acknowledgment.html 275 */ 276 if (gdb_cur->gdb_dbfeatures & GDB_DBGP_FEAT_RELIABLE) 277 gdb_tx_str(";QStartNoAckMode+"); 278 279 /* 280 * Future consideration: 281 * - vCont 282 * - multiprocess 283 */ 284 gdb_tx_end(); 285 return; 286 287 error: 288 *feat = 0; 289 gdb_tx_err(EINVAL); 290 } 291 292 /* 293 * A qXfer_context provides a vaguely generic way to generate a multi-packet 294 * response on the fly, making some assumptions about the size of sbuf writes 295 * vs actual packet length constraints. A non-byzantine gdb host should allow 296 * hundreds of bytes per packet or more. 297 * 298 * Upper layers are considered responsible for escaping the four forbidden 299 * characters '# $ } *'. 300 */ 301 struct qXfer_context { 302 struct sbuf sb; 303 size_t last_offset; 304 bool flushed; 305 bool lastmessage; 306 char xfer_buf[GDB_BUFSZ]; 307 }; 308 309 static int 310 qXfer_drain(void *v, const char *buf, int len) 311 { 312 struct qXfer_context *qx; 313 314 if (len < 0) 315 return (-EINVAL); 316 317 qx = v; 318 if (qx->flushed) { 319 /* 320 * Overflow. We lost some message. Maybe the packet size is 321 * ridiculously small. 322 */ 323 printf("%s: Overflow in qXfer detected.\n", __func__); 324 return (-ENOBUFS); 325 } 326 327 qx->last_offset += len; 328 qx->flushed = true; 329 330 if (qx->lastmessage) 331 gdb_tx_begin('l'); 332 else 333 gdb_tx_begin('m'); 334 335 memcpy(gdb_txp, buf, len); 336 gdb_txp += len; 337 338 gdb_tx_end(); 339 return (len); 340 } 341 342 static int 343 init_qXfer_ctx(struct qXfer_context *qx, uintmax_t len) 344 { 345 346 /* Protocol (max) length field includes framing overhead. */ 347 if (len < sizeof("$m#nn")) 348 return (ENOSPC); 349 350 len -= 4; 351 len = ummin(len, GDB_BUFSZ - 1); 352 353 qx->last_offset = 0; 354 qx->flushed = false; 355 qx->lastmessage = false; 356 sbuf_new(&qx->sb, qx->xfer_buf, len, SBUF_FIXEDLEN); 357 sbuf_set_drain(&qx->sb, qXfer_drain, qx); 358 return (0); 359 } 360 361 /* 362 * Squashes special XML and GDB characters down to _. Sorry. 363 */ 364 static void 365 qXfer_escape_xmlattr_str(char *dst, size_t dstlen, const char *src) 366 { 367 static const char *forbidden = "#$}*"; 368 369 size_t i; 370 char c; 371 372 for (i = 0; i < dstlen - 1 && *src != 0; src++, i++) { 373 c = *src; 374 /* XML attr filter */ 375 if (c < 32) 376 c = '_'; 377 /* We assume attributes will be "" quoted. */ 378 if (c == '<' || c == '&' || c == '"') 379 c = '_'; 380 381 /* GDB escape. */ 382 if (strchr(forbidden, c) != NULL) { 383 /* 384 * It would be nice to escape these properly, but to do 385 * it correctly we need to escape them in the transmit 386 * layer, potentially doubling our buffer requirements. 387 * For now, avoid breaking the protocol by squashing 388 * them to underscore. 389 */ 390 #if 0 391 *dst++ = '}'; 392 c ^= 0x20; 393 #endif 394 c = '_'; 395 } 396 *dst++ = c; 397 } 398 if (*src != 0) 399 printf("XXX%s: overflow; API misuse\n", __func__); 400 401 *dst = 0; 402 } 403 404 /* 405 * Dynamically generate qXfer:threads document, one packet at a time. 406 * 407 * The format is loosely described[0], although it does not seem that the 408 * <?xml?> mentioned on that page is required. 409 * 410 * [0]: https://sourceware.org/gdb/current/onlinedocs/gdb/Thread-List-Format.html 411 */ 412 static void 413 do_qXfer_threads_read(void) 414 { 415 /* Kludgy context */ 416 static struct { 417 struct qXfer_context qXfer; 418 /* Kludgy state machine */ 419 struct thread *iter; 420 enum { 421 XML_START_THREAD, /* '<thread' */ 422 XML_THREAD_ID, /* ' id="xxx"' */ 423 XML_THREAD_CORE, /* ' core="yyy"' */ 424 XML_THREAD_NAME, /* ' name="zzz"' */ 425 XML_THREAD_EXTRA, /* '> ...' */ 426 XML_END_THREAD, /* '</thread>' */ 427 XML_SENT_END_THREADS, /* '</threads>' */ 428 } next_step; 429 } ctx; 430 static char td_name_escape[MAXCOMLEN * 2 + 1]; 431 432 const char *name_src; 433 uintmax_t offset, len; 434 int error; 435 436 /* Annex part must be empty. */ 437 if (gdb_rx_char() != ':') 438 goto misformed_request; 439 440 if (gdb_rx_varhex(&offset) != 0 || 441 gdb_rx_char() != ',' || 442 gdb_rx_varhex(&len) != 0) 443 goto misformed_request; 444 445 /* 446 * Validate resume xfers. 447 */ 448 if (offset != 0) { 449 if (offset != ctx.qXfer.last_offset) { 450 printf("%s: Resumed offset %ju != expected %zu\n", 451 __func__, offset, ctx.qXfer.last_offset); 452 error = ESPIPE; 453 goto request_error; 454 } 455 ctx.qXfer.flushed = false; 456 } 457 458 if (offset == 0) { 459 ctx.iter = kdb_thr_first(); 460 ctx.next_step = XML_START_THREAD; 461 error = init_qXfer_ctx(&ctx.qXfer, len); 462 if (error != 0) 463 goto request_error; 464 465 sbuf_cat(&ctx.qXfer.sb, "<threads>"); 466 } 467 468 while (!ctx.qXfer.flushed && ctx.iter != NULL) { 469 switch (ctx.next_step) { 470 case XML_START_THREAD: 471 ctx.next_step = XML_THREAD_ID; 472 sbuf_cat(&ctx.qXfer.sb, "<thread"); 473 continue; 474 475 case XML_THREAD_ID: 476 ctx.next_step = XML_THREAD_CORE; 477 sbuf_printf(&ctx.qXfer.sb, " id=\"%jx\"", 478 (uintmax_t)ctx.iter->td_tid); 479 continue; 480 481 case XML_THREAD_CORE: 482 ctx.next_step = XML_THREAD_NAME; 483 if (ctx.iter->td_oncpu != NOCPU) { 484 sbuf_printf(&ctx.qXfer.sb, " core=\"%d\"", 485 ctx.iter->td_oncpu); 486 } 487 continue; 488 489 case XML_THREAD_NAME: 490 ctx.next_step = XML_THREAD_EXTRA; 491 492 if (ctx.iter->td_name[0] != 0) 493 name_src = ctx.iter->td_name; 494 else if (ctx.iter->td_proc != NULL && 495 ctx.iter->td_proc->p_comm[0] != 0) 496 name_src = ctx.iter->td_proc->p_comm; 497 else 498 continue; 499 500 qXfer_escape_xmlattr_str(td_name_escape, 501 sizeof(td_name_escape), name_src); 502 sbuf_printf(&ctx.qXfer.sb, " name=\"%s\"", 503 td_name_escape); 504 continue; 505 506 case XML_THREAD_EXTRA: 507 ctx.next_step = XML_END_THREAD; 508 509 sbuf_putc(&ctx.qXfer.sb, '>'); 510 511 if (TD_GET_STATE(ctx.iter) == TDS_RUNNING) 512 sbuf_cat(&ctx.qXfer.sb, "Running"); 513 else if (TD_GET_STATE(ctx.iter) == TDS_RUNQ) 514 sbuf_cat(&ctx.qXfer.sb, "RunQ"); 515 else if (TD_GET_STATE(ctx.iter) == TDS_CAN_RUN) 516 sbuf_cat(&ctx.qXfer.sb, "CanRun"); 517 else if (TD_ON_LOCK(ctx.iter)) 518 sbuf_cat(&ctx.qXfer.sb, "Blocked"); 519 else if (TD_IS_SLEEPING(ctx.iter)) 520 sbuf_cat(&ctx.qXfer.sb, "Sleeping"); 521 else if (TD_IS_SWAPPED(ctx.iter)) 522 sbuf_cat(&ctx.qXfer.sb, "Swapped"); 523 else if (TD_AWAITING_INTR(ctx.iter)) 524 sbuf_cat(&ctx.qXfer.sb, "IthreadWait"); 525 else if (TD_IS_SUSPENDED(ctx.iter)) 526 sbuf_cat(&ctx.qXfer.sb, "Suspended"); 527 else 528 sbuf_cat(&ctx.qXfer.sb, "???"); 529 continue; 530 531 case XML_END_THREAD: 532 ctx.next_step = XML_START_THREAD; 533 sbuf_cat(&ctx.qXfer.sb, "</thread>"); 534 ctx.iter = kdb_thr_next(ctx.iter); 535 continue; 536 537 /* 538 * This one isn't part of the looping state machine, 539 * but GCC complains if you leave an enum value out of the 540 * select. 541 */ 542 case XML_SENT_END_THREADS: 543 /* NOTREACHED */ 544 break; 545 } 546 } 547 if (ctx.qXfer.flushed) 548 return; 549 550 if (ctx.next_step != XML_SENT_END_THREADS) { 551 ctx.next_step = XML_SENT_END_THREADS; 552 sbuf_cat(&ctx.qXfer.sb, "</threads>"); 553 } 554 if (ctx.qXfer.flushed) 555 return; 556 557 ctx.qXfer.lastmessage = true; 558 sbuf_finish(&ctx.qXfer.sb); 559 sbuf_delete(&ctx.qXfer.sb); 560 ctx.qXfer.last_offset = 0; 561 return; 562 563 misformed_request: 564 /* 565 * GDB "General-Query-Packets.html" qXfer-read anchor specifically 566 * documents an E00 code for malformed requests or invalid annex. 567 * Non-zero codes indicate invalid offset or "error reading the data." 568 */ 569 error = 0; 570 request_error: 571 gdb_tx_err(error); 572 return; 573 } 574 575 /* 576 * A set of standardized transfers from "special data areas." 577 * 578 * We've already matched on "qXfer:" and advanced the rx packet buffer past 579 * that bit. Parse out the rest of the packet and generate an appropriate 580 * response. 581 */ 582 static void 583 do_qXfer(void) 584 { 585 if (!gdb_rx_equal("threads:")) 586 goto unrecognized; 587 588 if (!gdb_rx_equal("read:")) 589 goto unrecognized; 590 591 do_qXfer_threads_read(); 592 return; 593 594 unrecognized: 595 gdb_tx_empty(); 596 return; 597 } 598 599 static void 600 gdb_handle_detach(void) 601 { 602 kdb_cpu_clear_singlestep(); 603 gdb_listening = 0; 604 605 if (gdb_cur->gdb_dbfeatures & GDB_DBGP_FEAT_WANTTERM) 606 gdb_cur->gdb_term(); 607 608 #ifdef DDB 609 if (!gdb_return_to_ddb) 610 return; 611 612 gdb_return_to_ddb = false; 613 614 if (kdb_dbbe_select("ddb") != 0) 615 printf("The ddb backend could not be selected.\n"); 616 #endif 617 } 618 619 /* 620 * Handle a 'Z' packet: set a breakpoint or watchpoint. 621 * 622 * Currently, only watchpoints are supported. 623 */ 624 static void 625 gdb_z_insert(void) 626 { 627 intmax_t addr, length; 628 char ztype; 629 int error; 630 631 ztype = gdb_rx_char(); 632 if (gdb_rx_char() != ',' || gdb_rx_varhex(&addr) || 633 gdb_rx_char() != ',' || gdb_rx_varhex(&length)) { 634 error = EINVAL; 635 goto fail; 636 } 637 638 switch (ztype) { 639 case '2': /* write watchpoint */ 640 error = kdb_cpu_set_watchpoint((vm_offset_t)addr, 641 (vm_size_t)length, KDB_DBG_ACCESS_W); 642 break; 643 case '3': /* read watchpoint */ 644 error = kdb_cpu_set_watchpoint((vm_offset_t)addr, 645 (vm_size_t)length, KDB_DBG_ACCESS_R); 646 break; 647 case '4': /* access (RW) watchpoint */ 648 error = kdb_cpu_set_watchpoint((vm_offset_t)addr, 649 (vm_size_t)length, KDB_DBG_ACCESS_RW); 650 break; 651 case '1': /* hardware breakpoint */ 652 case '0': /* software breakpoint */ 653 /* Not implemented. */ 654 gdb_tx_empty(); 655 return; 656 default: 657 error = EINVAL; 658 break; 659 } 660 if (error != 0) 661 goto fail; 662 gdb_tx_ok(); 663 return; 664 fail: 665 gdb_tx_err(error); 666 return; 667 } 668 669 /* 670 * Handle a 'z' packet; clear a breakpoint or watchpoint. 671 * 672 * Currently, only watchpoints are supported. 673 */ 674 static void 675 gdb_z_remove(void) 676 { 677 intmax_t addr, length; 678 char ztype; 679 int error; 680 681 ztype = gdb_rx_char(); 682 if (gdb_rx_char() != ',' || gdb_rx_varhex(&addr) || 683 gdb_rx_char() != ',' || gdb_rx_varhex(&length)) { 684 error = EINVAL; 685 goto fail; 686 } 687 688 switch (ztype) { 689 case '2': /* write watchpoint */ 690 case '3': /* read watchpoint */ 691 case '4': /* access (RW) watchpoint */ 692 error = kdb_cpu_clr_watchpoint((vm_offset_t)addr, 693 (vm_size_t)length); 694 break; 695 case '1': /* hardware breakpoint */ 696 case '0': /* software breakpoint */ 697 /* Not implemented. */ 698 gdb_tx_empty(); 699 return; 700 default: 701 error = EINVAL; 702 break; 703 } 704 if (error != 0) 705 goto fail; 706 gdb_tx_ok(); 707 return; 708 fail: 709 gdb_tx_err(error); 710 return; 711 } 712 713 static int 714 gdb_trap(int type, int code) 715 { 716 jmp_buf jb; 717 struct thread *thr_iter; 718 void *prev_jb; 719 uint32_t host_features; 720 721 prev_jb = kdb_jmpbuf(jb); 722 if (setjmp(jb) != 0) { 723 printf("%s bailing, hopefully back to ddb!\n", __func__); 724 gdb_listening = 0; 725 (void)kdb_jmpbuf(prev_jb); 726 return (1); 727 } 728 729 gdb_listening = 0; 730 gdb_ackmode = true; 731 732 /* 733 * Send a T packet. We currently do not support watchpoints (the 734 * awatch, rwatch or watch elements). 735 */ 736 gdb_tx_begin('T'); 737 gdb_tx_hex(gdb_cpu_signal(type, code), 2); 738 gdb_tx_varhex(GDB_REG_PC); 739 gdb_tx_char(':'); 740 gdb_tx_reg(GDB_REG_PC); 741 gdb_tx_char(';'); 742 gdb_cpu_stop_reason(type, code); 743 gdb_tx_str("thread:"); 744 gdb_tx_varhex((uintmax_t)kdb_thread->td_tid); 745 gdb_tx_char(';'); 746 gdb_tx_end(); /* XXX check error condition. */ 747 748 thr_iter = NULL; 749 while (gdb_rx_begin() == 0) { 750 /* printf("GDB: got '%s'\n", gdb_rxp); */ 751 switch (gdb_rx_char()) { 752 case '?': /* Last signal. */ 753 gdb_tx_begin('T'); 754 gdb_tx_hex(gdb_cpu_signal(type, code), 2); 755 gdb_tx_str("thread:"); 756 gdb_tx_varhex((long)kdb_thread->td_tid); 757 gdb_tx_char(';'); 758 gdb_tx_end(); 759 break; 760 case 'c': { /* Continue. */ 761 uintmax_t addr; 762 register_t pc; 763 if (!gdb_rx_varhex(&addr)) { 764 pc = addr; 765 gdb_cpu_setreg(GDB_REG_PC, &pc); 766 } 767 kdb_cpu_clear_singlestep(); 768 gdb_listening = 1; 769 return (1); 770 } 771 case 'C': { /* Continue with signal. */ 772 uintmax_t addr, sig; 773 register_t pc; 774 if (!gdb_rx_varhex(&sig) && gdb_rx_char() == ';' && 775 !gdb_rx_varhex(&addr)) { 776 pc = addr; 777 gdb_cpu_setreg(GDB_REG_PC, &pc); 778 } 779 kdb_cpu_clear_singlestep(); 780 gdb_listening = 1; 781 return (1); 782 } 783 case 'D': { /* Detach */ 784 gdb_tx_ok(); 785 gdb_handle_detach(); 786 return (1); 787 } 788 case 'g': { /* Read registers. */ 789 size_t r; 790 gdb_tx_begin(0); 791 for (r = 0; r < GDB_NREGS; r++) 792 gdb_tx_reg(r); 793 gdb_tx_end(); 794 break; 795 } 796 case 'G': { /* Write registers. */ 797 char *val; 798 bool success; 799 size_t r; 800 for (success = true, r = 0; r < GDB_NREGS; r++) { 801 val = gdb_rxp; 802 if (!gdb_rx_mem(val, gdb_cpu_regsz(r))) { 803 gdb_tx_err(EINVAL); 804 success = false; 805 break; 806 } 807 gdb_cpu_setreg(r, val); 808 } 809 if (success) 810 gdb_tx_ok(); 811 break; 812 } 813 case 'H': { /* Set thread. */ 814 intmax_t tid; 815 struct thread *thr; 816 817 /* Ignore 'g' (general) or 'c' (continue) flag. */ 818 (void) gdb_rx_char(); 819 820 if (gdb_rx_varhex(&tid)) { 821 gdb_tx_err(EINVAL); 822 break; 823 } 824 if (tid > 0) { 825 thr = kdb_thr_lookup(tid); 826 if (thr == NULL) { 827 gdb_tx_err(ENOENT); 828 break; 829 } 830 kdb_thr_select(thr); 831 } 832 gdb_tx_ok(); 833 break; 834 } 835 case 'k': /* Kill request. */ 836 gdb_handle_detach(); 837 return (1); 838 case 'm': { /* Read memory. */ 839 uintmax_t addr, size; 840 if (gdb_rx_varhex(&addr) || gdb_rx_char() != ',' || 841 gdb_rx_varhex(&size)) { 842 gdb_tx_err(EINVAL); 843 break; 844 } 845 gdb_tx_begin(0); 846 if (gdb_tx_mem((char *)(uintptr_t)addr, size)) 847 gdb_tx_end(); 848 else 849 gdb_tx_err(EIO); 850 break; 851 } 852 case 'M': { /* Write memory. */ 853 uintmax_t addr, size; 854 if (gdb_rx_varhex(&addr) || gdb_rx_char() != ',' || 855 gdb_rx_varhex(&size) || gdb_rx_char() != ':') { 856 gdb_tx_err(EINVAL); 857 break; 858 } 859 if (gdb_rx_mem((char *)(uintptr_t)addr, size) == 0) 860 gdb_tx_err(EIO); 861 else 862 gdb_tx_ok(); 863 break; 864 } 865 case 'p': { /* Read register. */ 866 uintmax_t reg; 867 if (gdb_rx_varhex(®)) { 868 gdb_tx_err(EINVAL); 869 break; 870 } 871 gdb_tx_begin(0); 872 gdb_tx_reg(reg); 873 gdb_tx_end(); 874 break; 875 } 876 case 'P': { /* Write register. */ 877 char *val; 878 uintmax_t reg; 879 val = gdb_rxp; 880 if (gdb_rx_varhex(®) || gdb_rx_char() != '=' || 881 !gdb_rx_mem(val, gdb_cpu_regsz(reg))) { 882 gdb_tx_err(EINVAL); 883 break; 884 } 885 gdb_cpu_setreg(reg, val); 886 gdb_tx_ok(); 887 break; 888 } 889 case 'q': /* General query. */ 890 if (gdb_rx_equal("C")) { 891 gdb_tx_begin('Q'); 892 gdb_tx_char('C'); 893 gdb_tx_varhex((long)kdb_thread->td_tid); 894 gdb_tx_end(); 895 } else if (gdb_rx_equal("Supported")) { 896 gdb_do_qsupported(&host_features); 897 } else if (gdb_rx_equal("fThreadInfo")) { 898 thr_iter = kdb_thr_first(); 899 gdb_do_threadinfo(&thr_iter); 900 } else if (gdb_rx_equal("sThreadInfo")) { 901 gdb_do_threadinfo(&thr_iter); 902 } else if (gdb_rx_equal("Xfer:")) { 903 do_qXfer(); 904 } else if (gdb_rx_equal("Search:memory:")) { 905 gdb_do_mem_search(); 906 #ifdef __powerpc__ 907 } else if (gdb_rx_equal("Offsets")) { 908 gdb_cpu_do_offsets(); 909 #endif 910 } else if (!gdb_cpu_query()) 911 gdb_tx_empty(); 912 break; 913 case 'Q': 914 if (gdb_rx_equal("StartNoAckMode")) { 915 if ((gdb_cur->gdb_dbfeatures & 916 GDB_DBGP_FEAT_RELIABLE) == 0) { 917 /* 918 * Shouldn't happen if we didn't 919 * advertise support. Reject. 920 */ 921 gdb_tx_empty(); 922 break; 923 } 924 gdb_ackmode = false; 925 gdb_tx_ok(); 926 } else 927 gdb_tx_empty(); 928 break; 929 case 's': { /* Step. */ 930 uintmax_t addr; 931 register_t pc; 932 if (!gdb_rx_varhex(&addr)) { 933 pc = addr; 934 gdb_cpu_setreg(GDB_REG_PC, &pc); 935 } 936 kdb_cpu_set_singlestep(); 937 gdb_listening = 1; 938 return (1); 939 } 940 case 'S': { /* Step with signal. */ 941 uintmax_t addr, sig; 942 register_t pc; 943 if (!gdb_rx_varhex(&sig) && gdb_rx_char() == ';' && 944 !gdb_rx_varhex(&addr)) { 945 pc = addr; 946 gdb_cpu_setreg(GDB_REG_PC, &pc); 947 } 948 kdb_cpu_set_singlestep(); 949 gdb_listening = 1; 950 return (1); 951 } 952 case 'T': { /* Thread alive. */ 953 intmax_t tid; 954 if (gdb_rx_varhex(&tid)) { 955 gdb_tx_err(EINVAL); 956 break; 957 } 958 if (kdb_thr_lookup(tid) != NULL) 959 gdb_tx_ok(); 960 else 961 gdb_tx_err(ENOENT); 962 break; 963 } 964 case 'z': { /* Remove watchpoint. */ 965 gdb_z_remove(); 966 break; 967 } 968 case 'Z': { /* Set watchpoint. */ 969 gdb_z_insert(); 970 break; 971 } 972 case EOF: 973 /* Empty command. Treat as unknown command. */ 974 /* FALLTHROUGH */ 975 default: 976 /* Unknown command. Send empty response. */ 977 gdb_tx_empty(); 978 break; 979 } 980 } 981 (void)kdb_jmpbuf(prev_jb); 982 return (0); 983 } 984