1/* Main code for remote server for GDB. 2 Copyright (C) 1989, 1993, 1994, 1995, 1997, 1998, 1999, 2000, 2002, 2003, 3 2004, 2005, 2006, 2007 Free Software Foundation, Inc. 4 5 This file is part of GDB. 6 7 This program is free software; you can redistribute it and/or modify 8 it under the terms of the GNU General Public License as published by 9 the Free Software Foundation; either version 3 of the License, or 10 (at your option) any later version. 11 12 This program is distributed in the hope that it will be useful, 13 but WITHOUT ANY WARRANTY; without even the implied warranty of 14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 15 GNU General Public License for more details. 16 17 You should have received a copy of the GNU General Public License 18 along with this program. If not, see <http://www.gnu.org/licenses/>. */ 19 20#include "server.h" 21 22#if HAVE_UNISTD_H 23#include <unistd.h> 24#endif 25#if HAVE_SIGNAL_H 26#include <signal.h> 27#endif 28#if HAVE_SYS_WAIT_H 29#include <sys/wait.h> 30#endif 31 32unsigned long cont_thread; 33unsigned long general_thread; 34unsigned long step_thread; 35unsigned long thread_from_wait; 36unsigned long old_thread_from_wait; 37int extended_protocol; 38int server_waiting; 39 40/* Enable miscellaneous debugging output. The name is historical - it 41 was originally used to debug LinuxThreads support. */ 42int debug_threads; 43 44int pass_signals[TARGET_SIGNAL_LAST]; 45 46jmp_buf toplevel; 47 48/* The PID of the originally created or attached inferior. Used to 49 send signals to the process when GDB sends us an asynchronous interrupt 50 (user hitting Control-C in the client), and to wait for the child to exit 51 when no longer debugging it. */ 52 53unsigned long signal_pid; 54 55#ifdef SIGTTOU 56/* A file descriptor for the controlling terminal. */ 57int terminal_fd; 58 59/* TERMINAL_FD's original foreground group. */ 60pid_t old_foreground_pgrp; 61 62/* Hand back terminal ownership to the original foreground group. */ 63 64static void 65restore_old_foreground_pgrp (void) 66{ 67 tcsetpgrp (terminal_fd, old_foreground_pgrp); 68} 69#endif 70 71static int 72start_inferior (char *argv[], char *statusptr) 73{ 74#ifdef SIGTTOU 75 signal (SIGTTOU, SIG_DFL); 76 signal (SIGTTIN, SIG_DFL); 77#endif 78 79 signal_pid = create_inferior (argv[0], argv); 80 81 /* FIXME: we don't actually know at this point that the create 82 actually succeeded. We won't know that until we wait. */ 83 fprintf (stderr, "Process %s created; pid = %ld\n", argv[0], 84 signal_pid); 85 fflush (stderr); 86 87#ifdef SIGTTOU 88 signal (SIGTTOU, SIG_IGN); 89 signal (SIGTTIN, SIG_IGN); 90 terminal_fd = fileno (stderr); 91 old_foreground_pgrp = tcgetpgrp (terminal_fd); 92 tcsetpgrp (terminal_fd, signal_pid); 93 atexit (restore_old_foreground_pgrp); 94#endif 95 96 /* Wait till we are at 1st instruction in program, return signal 97 number (assuming success). */ 98 return mywait (statusptr, 0); 99} 100 101static int 102attach_inferior (int pid, char *statusptr, int *sigptr) 103{ 104 /* myattach should return -1 if attaching is unsupported, 105 0 if it succeeded, and call error() otherwise. */ 106 107 if (myattach (pid) != 0) 108 return -1; 109 110 fprintf (stderr, "Attached; pid = %d\n", pid); 111 fflush (stderr); 112 113 /* FIXME - It may be that we should get the SIGNAL_PID from the 114 attach function, so that it can be the main thread instead of 115 whichever we were told to attach to. */ 116 signal_pid = pid; 117 118 *sigptr = mywait (statusptr, 0); 119 120 /* GDB knows to ignore the first SIGSTOP after attaching to a running 121 process using the "attach" command, but this is different; it's 122 just using "target remote". Pretend it's just starting up. */ 123 if (*statusptr == 'T' && *sigptr == TARGET_SIGNAL_STOP) 124 *sigptr = TARGET_SIGNAL_TRAP; 125 126 return 0; 127} 128 129extern int remote_debug; 130 131/* Decode a qXfer read request. Return 0 if everything looks OK, 132 or -1 otherwise. */ 133 134static int 135decode_xfer_read (char *buf, char **annex, CORE_ADDR *ofs, unsigned int *len) 136{ 137 /* Extract and NUL-terminate the annex. */ 138 *annex = buf; 139 while (*buf && *buf != ':') 140 buf++; 141 if (*buf == '\0') 142 return -1; 143 *buf++ = 0; 144 145 /* After the read marker and annex, qXfer looks like a 146 traditional 'm' packet. */ 147 decode_m_packet (buf, ofs, len); 148 149 return 0; 150} 151 152/* Write the response to a successful qXfer read. Returns the 153 length of the (binary) data stored in BUF, corresponding 154 to as much of DATA/LEN as we could fit. IS_MORE controls 155 the first character of the response. */ 156static int 157write_qxfer_response (char *buf, const void *data, int len, int is_more) 158{ 159 int out_len; 160 161 if (is_more) 162 buf[0] = 'm'; 163 else 164 buf[0] = 'l'; 165 166 return remote_escape_output (data, len, (unsigned char *) buf + 1, &out_len, 167 PBUFSIZ - 2) + 1; 168} 169 170/* Handle all of the extended 'Q' packets. */ 171void 172handle_general_set (char *own_buf) 173{ 174 if (strncmp ("QPassSignals:", own_buf, strlen ("QPassSignals:")) == 0) 175 { 176 int numsigs = (int) TARGET_SIGNAL_LAST, i; 177 const char *p = own_buf + strlen ("QPassSignals:"); 178 CORE_ADDR cursig; 179 180 p = decode_address_to_semicolon (&cursig, p); 181 for (i = 0; i < numsigs; i++) 182 { 183 if (i == cursig) 184 { 185 pass_signals[i] = 1; 186 if (*p == '\0') 187 /* Keep looping, to clear the remaining signals. */ 188 cursig = -1; 189 else 190 p = decode_address_to_semicolon (&cursig, p); 191 } 192 else 193 pass_signals[i] = 0; 194 } 195 strcpy (own_buf, "OK"); 196 return; 197 } 198 199 /* Otherwise we didn't know what packet it was. Say we didn't 200 understand it. */ 201 own_buf[0] = 0; 202} 203 204static const char * 205get_features_xml (const char *annex) 206{ 207 static int features_supported = -1; 208 static char *document; 209 210#ifdef USE_XML 211 extern const char *const xml_builtin[][2]; 212 int i; 213 214 /* Look for the annex. */ 215 for (i = 0; xml_builtin[i][0] != NULL; i++) 216 if (strcmp (annex, xml_builtin[i][0]) == 0) 217 break; 218 219 if (xml_builtin[i][0] != NULL) 220 return xml_builtin[i][1]; 221#endif 222 223 if (strcmp (annex, "target.xml") != 0) 224 return NULL; 225 226 if (features_supported == -1) 227 { 228 const char *arch = NULL; 229 if (the_target->arch_string != NULL) 230 arch = (*the_target->arch_string) (); 231 232 if (arch == NULL) 233 features_supported = 0; 234 else 235 { 236 features_supported = 1; 237 document = malloc (64 + strlen (arch)); 238 snprintf (document, 64 + strlen (arch), 239 "<target><architecture>%s</architecture></target>", 240 arch); 241 } 242 } 243 244 return document; 245} 246 247void 248monitor_show_help (void) 249{ 250 monitor_output ("The following monitor commands are supported:\n"); 251 monitor_output (" set debug <0|1>\n"); 252 monitor_output (" Enable general debugging messages\n"); 253 monitor_output (" set remote-debug <0|1>\n"); 254 monitor_output (" Enable remote protocol debugging messages\n"); 255} 256 257/* Handle all of the extended 'q' packets. */ 258void 259handle_query (char *own_buf, int packet_len, int *new_packet_len_p) 260{ 261 static struct inferior_list_entry *thread_ptr; 262 263 /* Reply the current thread id. */ 264 if (strcmp ("qC", own_buf) == 0) 265 { 266 thread_ptr = all_threads.head; 267 sprintf (own_buf, "QC%x", 268 thread_to_gdb_id ((struct thread_info *)thread_ptr)); 269 return; 270 } 271 272 if (strcmp ("qSymbol::", own_buf) == 0) 273 { 274 if (the_target->look_up_symbols != NULL) 275 (*the_target->look_up_symbols) (); 276 277 strcpy (own_buf, "OK"); 278 return; 279 } 280 281 if (strcmp ("qfThreadInfo", own_buf) == 0) 282 { 283 thread_ptr = all_threads.head; 284 sprintf (own_buf, "m%x", thread_to_gdb_id ((struct thread_info *)thread_ptr)); 285 thread_ptr = thread_ptr->next; 286 return; 287 } 288 289 if (strcmp ("qsThreadInfo", own_buf) == 0) 290 { 291 if (thread_ptr != NULL) 292 { 293 sprintf (own_buf, "m%x", thread_to_gdb_id ((struct thread_info *)thread_ptr)); 294 thread_ptr = thread_ptr->next; 295 return; 296 } 297 else 298 { 299 sprintf (own_buf, "l"); 300 return; 301 } 302 } 303 304 if (the_target->read_offsets != NULL 305 && strcmp ("qOffsets", own_buf) == 0) 306 { 307 CORE_ADDR text, data; 308 309 if (the_target->read_offsets (&text, &data)) 310 sprintf (own_buf, "Text=%lX;Data=%lX;Bss=%lX", 311 (long)text, (long)data, (long)data); 312 else 313 write_enn (own_buf); 314 315 return; 316 } 317 318 if (the_target->qxfer_spu != NULL 319 && strncmp ("qXfer:spu:read:", own_buf, 15) == 0) 320 { 321 char *annex; 322 int n; 323 unsigned int len; 324 CORE_ADDR ofs; 325 unsigned char *spu_buf; 326 327 strcpy (own_buf, "E00"); 328 if (decode_xfer_read (own_buf + 15, &annex, &ofs, &len) < 0) 329 return; 330 if (len > PBUFSIZ - 2) 331 len = PBUFSIZ - 2; 332 spu_buf = malloc (len + 1); 333 if (!spu_buf) 334 return; 335 336 n = (*the_target->qxfer_spu) (annex, spu_buf, NULL, ofs, len + 1); 337 if (n < 0) 338 write_enn (own_buf); 339 else if (n > len) 340 *new_packet_len_p = write_qxfer_response 341 (own_buf, spu_buf, len, 1); 342 else 343 *new_packet_len_p = write_qxfer_response 344 (own_buf, spu_buf, n, 0); 345 346 free (spu_buf); 347 return; 348 } 349 350 if (the_target->qxfer_spu != NULL 351 && strncmp ("qXfer:spu:write:", own_buf, 16) == 0) 352 { 353 char *annex; 354 int n; 355 unsigned int len; 356 CORE_ADDR ofs; 357 unsigned char *spu_buf; 358 359 strcpy (own_buf, "E00"); 360 spu_buf = malloc (packet_len - 15); 361 if (!spu_buf) 362 return; 363 if (decode_xfer_write (own_buf + 16, packet_len - 16, &annex, 364 &ofs, &len, spu_buf) < 0) 365 { 366 free (spu_buf); 367 return; 368 } 369 370 n = (*the_target->qxfer_spu) 371 (annex, NULL, (unsigned const char *)spu_buf, ofs, len); 372 if (n < 0) 373 write_enn (own_buf); 374 else 375 sprintf (own_buf, "%x", n); 376 377 free (spu_buf); 378 return; 379 } 380 381 if (the_target->read_auxv != NULL 382 && strncmp ("qXfer:auxv:read:", own_buf, 16) == 0) 383 { 384 unsigned char *data; 385 int n; 386 CORE_ADDR ofs; 387 unsigned int len; 388 char *annex; 389 390 /* Reject any annex; grab the offset and length. */ 391 if (decode_xfer_read (own_buf + 16, &annex, &ofs, &len) < 0 392 || annex[0] != '\0') 393 { 394 strcpy (own_buf, "E00"); 395 return; 396 } 397 398 /* Read one extra byte, as an indicator of whether there is 399 more. */ 400 if (len > PBUFSIZ - 2) 401 len = PBUFSIZ - 2; 402 data = malloc (len + 1); 403 n = (*the_target->read_auxv) (ofs, data, len + 1); 404 if (n < 0) 405 write_enn (own_buf); 406 else if (n > len) 407 *new_packet_len_p = write_qxfer_response (own_buf, data, len, 1); 408 else 409 *new_packet_len_p = write_qxfer_response (own_buf, data, n, 0); 410 411 free (data); 412 413 return; 414 } 415 416 if (strncmp ("qXfer:features:read:", own_buf, 20) == 0) 417 { 418 CORE_ADDR ofs; 419 unsigned int len, total_len; 420 const char *document; 421 char *annex; 422 423 /* Check for support. */ 424 document = get_features_xml ("target.xml"); 425 if (document == NULL) 426 { 427 own_buf[0] = '\0'; 428 return; 429 } 430 431 /* Grab the annex, offset, and length. */ 432 if (decode_xfer_read (own_buf + 20, &annex, &ofs, &len) < 0) 433 { 434 strcpy (own_buf, "E00"); 435 return; 436 } 437 438 /* Now grab the correct annex. */ 439 document = get_features_xml (annex); 440 if (document == NULL) 441 { 442 strcpy (own_buf, "E00"); 443 return; 444 } 445 446 total_len = strlen (document); 447 if (len > PBUFSIZ - 2) 448 len = PBUFSIZ - 2; 449 450 if (ofs > total_len) 451 write_enn (own_buf); 452 else if (len < total_len - ofs) 453 *new_packet_len_p = write_qxfer_response (own_buf, document + ofs, 454 len, 1); 455 else 456 *new_packet_len_p = write_qxfer_response (own_buf, document + ofs, 457 total_len - ofs, 0); 458 459 return; 460 } 461 462 if (strncmp ("qXfer:libraries:read:", own_buf, 21) == 0) 463 { 464 CORE_ADDR ofs; 465 unsigned int len, total_len; 466 char *document, *p; 467 struct inferior_list_entry *dll_ptr; 468 char *annex; 469 470 /* Reject any annex; grab the offset and length. */ 471 if (decode_xfer_read (own_buf + 21, &annex, &ofs, &len) < 0 472 || annex[0] != '\0') 473 { 474 strcpy (own_buf, "E00"); 475 return; 476 } 477 478 /* Over-estimate the necessary memory. Assume that every character 479 in the library name must be escaped. */ 480 total_len = 64; 481 for (dll_ptr = all_dlls.head; dll_ptr != NULL; dll_ptr = dll_ptr->next) 482 total_len += 128 + 6 * strlen (((struct dll_info *) dll_ptr)->name); 483 484 document = malloc (total_len); 485 strcpy (document, "<library-list>\n"); 486 p = document + strlen (document); 487 488 for (dll_ptr = all_dlls.head; dll_ptr != NULL; dll_ptr = dll_ptr->next) 489 { 490 struct dll_info *dll = (struct dll_info *) dll_ptr; 491 char *name; 492 493 strcpy (p, " <library name=\""); 494 p = p + strlen (p); 495 name = xml_escape_text (dll->name); 496 strcpy (p, name); 497 free (name); 498 p = p + strlen (p); 499 strcpy (p, "\"><segment address=\""); 500 p = p + strlen (p); 501 sprintf (p, "0x%lx", (long) dll->base_addr); 502 p = p + strlen (p); 503 strcpy (p, "\"/></library>\n"); 504 p = p + strlen (p); 505 } 506 507 strcpy (p, "</library-list>\n"); 508 509 total_len = strlen (document); 510 if (len > PBUFSIZ - 2) 511 len = PBUFSIZ - 2; 512 513 if (ofs > total_len) 514 write_enn (own_buf); 515 else if (len < total_len - ofs) 516 *new_packet_len_p = write_qxfer_response (own_buf, document + ofs, 517 len, 1); 518 else 519 *new_packet_len_p = write_qxfer_response (own_buf, document + ofs, 520 total_len - ofs, 0); 521 522 free (document); 523 return; 524 } 525 526 /* Protocol features query. */ 527 if (strncmp ("qSupported", own_buf, 10) == 0 528 && (own_buf[10] == ':' || own_buf[10] == '\0')) 529 { 530 sprintf (own_buf, "PacketSize=%x;QPassSignals+", PBUFSIZ - 1); 531 532 /* We do not have any hook to indicate whether the target backend 533 supports qXfer:libraries:read, so always report it. */ 534 strcat (own_buf, ";qXfer:libraries:read+"); 535 536 if (the_target->read_auxv != NULL) 537 strcat (own_buf, ";qXfer:auxv:read+"); 538 539 if (the_target->qxfer_spu != NULL) 540 strcat (own_buf, ";qXfer:spu:read+;qXfer:spu:write+"); 541 542 if (get_features_xml ("target.xml") != NULL) 543 strcat (own_buf, ";qXfer:features:read+"); 544 545 return; 546 } 547 548 /* Thread-local storage support. */ 549 if (the_target->get_tls_address != NULL 550 && strncmp ("qGetTLSAddr:", own_buf, 12) == 0) 551 { 552 char *p = own_buf + 12; 553 CORE_ADDR parts[3], address = 0; 554 int i, err; 555 556 for (i = 0; i < 3; i++) 557 { 558 char *p2; 559 int len; 560 561 if (p == NULL) 562 break; 563 564 p2 = strchr (p, ','); 565 if (p2) 566 { 567 len = p2 - p; 568 p2++; 569 } 570 else 571 { 572 len = strlen (p); 573 p2 = NULL; 574 } 575 576 decode_address (&parts[i], p, len); 577 p = p2; 578 } 579 580 if (p != NULL || i < 3) 581 err = 1; 582 else 583 { 584 struct thread_info *thread = gdb_id_to_thread (parts[0]); 585 586 if (thread == NULL) 587 err = 2; 588 else 589 err = the_target->get_tls_address (thread, parts[1], parts[2], 590 &address); 591 } 592 593 if (err == 0) 594 { 595 sprintf (own_buf, "%llx", address); 596 return; 597 } 598 else if (err > 0) 599 { 600 write_enn (own_buf); 601 return; 602 } 603 604 /* Otherwise, pretend we do not understand this packet. */ 605 } 606 607 /* Handle "monitor" commands. */ 608 if (strncmp ("qRcmd,", own_buf, 6) == 0) 609 { 610 char *mon = malloc (PBUFSIZ); 611 int len = strlen (own_buf + 6); 612 613 if ((len % 1) != 0 || unhexify (mon, own_buf + 6, len / 2) != len / 2) 614 { 615 write_enn (own_buf); 616 free (mon); 617 return; 618 } 619 mon[len / 2] = '\0'; 620 621 write_ok (own_buf); 622 623 if (strcmp (mon, "set debug 1") == 0) 624 { 625 debug_threads = 1; 626 monitor_output ("Debug output enabled.\n"); 627 } 628 else if (strcmp (mon, "set debug 0") == 0) 629 { 630 debug_threads = 0; 631 monitor_output ("Debug output disabled.\n"); 632 } 633 else if (strcmp (mon, "set remote-debug 1") == 0) 634 { 635 remote_debug = 1; 636 monitor_output ("Protocol debug output enabled.\n"); 637 } 638 else if (strcmp (mon, "set remote-debug 0") == 0) 639 { 640 remote_debug = 0; 641 monitor_output ("Protocol debug output disabled.\n"); 642 } 643 else if (strcmp (mon, "help") == 0) 644 monitor_show_help (); 645 else 646 { 647 monitor_output ("Unknown monitor command.\n\n"); 648 monitor_show_help (); 649 write_enn (own_buf); 650 } 651 652 free (mon); 653 return; 654 } 655 656 /* Otherwise we didn't know what packet it was. Say we didn't 657 understand it. */ 658 own_buf[0] = 0; 659} 660 661/* Parse vCont packets. */ 662void 663handle_v_cont (char *own_buf, char *status, int *signal) 664{ 665 char *p, *q; 666 int n = 0, i = 0; 667 struct thread_resume *resume_info, default_action; 668 669 /* Count the number of semicolons in the packet. There should be one 670 for every action. */ 671 p = &own_buf[5]; 672 while (p) 673 { 674 n++; 675 p++; 676 p = strchr (p, ';'); 677 } 678 /* Allocate room for one extra action, for the default remain-stopped 679 behavior; if no default action is in the list, we'll need the extra 680 slot. */ 681 resume_info = malloc ((n + 1) * sizeof (resume_info[0])); 682 683 default_action.thread = -1; 684 default_action.leave_stopped = 1; 685 default_action.step = 0; 686 default_action.sig = 0; 687 688 p = &own_buf[5]; 689 i = 0; 690 while (*p) 691 { 692 p++; 693 694 resume_info[i].leave_stopped = 0; 695 696 if (p[0] == 's' || p[0] == 'S') 697 resume_info[i].step = 1; 698 else if (p[0] == 'c' || p[0] == 'C') 699 resume_info[i].step = 0; 700 else 701 goto err; 702 703 if (p[0] == 'S' || p[0] == 'C') 704 { 705 int sig; 706 sig = strtol (p + 1, &q, 16); 707 if (p == q) 708 goto err; 709 p = q; 710 711 if (!target_signal_to_host_p (sig)) 712 goto err; 713 resume_info[i].sig = target_signal_to_host (sig); 714 } 715 else 716 { 717 resume_info[i].sig = 0; 718 p = p + 1; 719 } 720 721 if (p[0] == 0) 722 { 723 resume_info[i].thread = -1; 724 default_action = resume_info[i]; 725 726 /* Note: we don't increment i here, we'll overwrite this entry 727 the next time through. */ 728 } 729 else if (p[0] == ':') 730 { 731 unsigned int gdb_id = strtoul (p + 1, &q, 16); 732 unsigned long thread_id; 733 734 if (p == q) 735 goto err; 736 p = q; 737 if (p[0] != ';' && p[0] != 0) 738 goto err; 739 740 thread_id = gdb_id_to_thread_id (gdb_id); 741 if (thread_id) 742 resume_info[i].thread = thread_id; 743 else 744 goto err; 745 746 i++; 747 } 748 } 749 750 resume_info[i] = default_action; 751 752 /* Still used in occasional places in the backend. */ 753 if (n == 1 && resume_info[0].thread != -1) 754 cont_thread = resume_info[0].thread; 755 else 756 cont_thread = -1; 757 set_desired_inferior (0); 758 759 (*the_target->resume) (resume_info); 760 761 free (resume_info); 762 763 *signal = mywait (status, 1); 764 prepare_resume_reply (own_buf, *status, *signal); 765 return; 766 767err: 768 write_enn (own_buf); 769 free (resume_info); 770 return; 771} 772 773/* Handle all of the extended 'v' packets. */ 774void 775handle_v_requests (char *own_buf, char *status, int *signal) 776{ 777 if (strncmp (own_buf, "vCont;", 6) == 0) 778 { 779 handle_v_cont (own_buf, status, signal); 780 return; 781 } 782 783 if (strncmp (own_buf, "vCont?", 6) == 0) 784 { 785 strcpy (own_buf, "vCont;c;C;s;S"); 786 return; 787 } 788 789 /* Otherwise we didn't know what packet it was. Say we didn't 790 understand it. */ 791 own_buf[0] = 0; 792 return; 793} 794 795void 796myresume (int step, int sig) 797{ 798 struct thread_resume resume_info[2]; 799 int n = 0; 800 801 if (step || sig || (cont_thread != 0 && cont_thread != -1)) 802 { 803 resume_info[0].thread 804 = ((struct inferior_list_entry *) current_inferior)->id; 805 resume_info[0].step = step; 806 resume_info[0].sig = sig; 807 resume_info[0].leave_stopped = 0; 808 n++; 809 } 810 resume_info[n].thread = -1; 811 resume_info[n].step = 0; 812 resume_info[n].sig = 0; 813 resume_info[n].leave_stopped = (cont_thread != 0 && cont_thread != -1); 814 815 (*the_target->resume) (resume_info); 816} 817 818static int attached; 819 820static void 821gdbserver_version (void) 822{ 823 printf ("GNU gdbserver %s\n" 824 "Copyright (C) 2007 Free Software Foundation, Inc.\n" 825 "gdbserver is free software, covered by the GNU General Public License.\n" 826 "This gdbserver was configured as \"%s\"\n", 827 version, host_name); 828} 829 830static void 831gdbserver_usage (void) 832{ 833 printf ("Usage:\tgdbserver COMM PROG [ARGS ...]\n" 834 "\tgdbserver COMM --attach PID\n" 835 "\n" 836 "COMM may either be a tty device (for serial debugging), or \n" 837 "HOST:PORT to listen for a TCP connection.\n"); 838} 839 840int 841main (int argc, char *argv[]) 842{ 843 char ch, status, *own_buf; 844 unsigned char *mem_buf; 845 int i = 0; 846 int signal; 847 unsigned int len; 848 CORE_ADDR mem_addr; 849 int bad_attach; 850 int pid; 851 char *arg_end; 852 853 if (argc >= 2 && strcmp (argv[1], "--version") == 0) 854 { 855 gdbserver_version (); 856 exit (0); 857 } 858 859 if (argc >= 2 && strcmp (argv[1], "--help") == 0) 860 { 861 gdbserver_usage (); 862 exit (0); 863 } 864 865 if (setjmp (toplevel)) 866 { 867 fprintf (stderr, "Exiting\n"); 868 exit (1); 869 } 870 871 bad_attach = 0; 872 pid = 0; 873 attached = 0; 874 if (argc >= 3 && strcmp (argv[2], "--attach") == 0) 875 { 876 if (argc == 4 877 && argv[3][0] != '\0' 878 && (pid = strtoul (argv[3], &arg_end, 10)) != 0 879 && *arg_end == '\0') 880 { 881 ; 882 } 883 else 884 bad_attach = 1; 885 } 886 887 if (argc < 3 || bad_attach) 888 { 889 gdbserver_usage (); 890 exit (1); 891 } 892 893 initialize_low (); 894 895 own_buf = malloc (PBUFSIZ + 1); 896 mem_buf = malloc (PBUFSIZ); 897 898 if (pid == 0) 899 { 900 /* Wait till we are at first instruction in program. */ 901 signal = start_inferior (&argv[2], &status); 902 903 /* We are now (hopefully) stopped at the first instruction of 904 the target process. This assumes that the target process was 905 successfully created. */ 906 907 /* Don't report shared library events on the initial connection, 908 even if some libraries are preloaded. */ 909 dlls_changed = 0; 910 } 911 else 912 { 913 switch (attach_inferior (pid, &status, &signal)) 914 { 915 case -1: 916 error ("Attaching not supported on this target"); 917 break; 918 default: 919 attached = 1; 920 break; 921 } 922 } 923 924 if (setjmp (toplevel)) 925 { 926 fprintf (stderr, "Killing inferior\n"); 927 kill_inferior (); 928 exit (1); 929 } 930 931 if (status == 'W' || status == 'X') 932 { 933 fprintf (stderr, "No inferior, GDBserver exiting.\n"); 934 exit (1); 935 } 936 937 while (1) 938 { 939 remote_open (argv[1]); 940 941 restart: 942 setjmp (toplevel); 943 while (1) 944 { 945 unsigned char sig; 946 int packet_len; 947 int new_packet_len = -1; 948 949 packet_len = getpkt (own_buf); 950 if (packet_len <= 0) 951 break; 952 953 i = 0; 954 ch = own_buf[i++]; 955 switch (ch) 956 { 957 case 'q': 958 handle_query (own_buf, packet_len, &new_packet_len); 959 break; 960 case 'Q': 961 handle_general_set (own_buf); 962 break; 963 case 'D': 964 fprintf (stderr, "Detaching from inferior\n"); 965 if (detach_inferior () != 0) 966 { 967 write_enn (own_buf); 968 putpkt (own_buf); 969 } 970 else 971 { 972 write_ok (own_buf); 973 putpkt (own_buf); 974 remote_close (); 975 976 /* If we are attached, then we can exit. Otherwise, we 977 need to hang around doing nothing, until the child 978 is gone. */ 979 if (!attached) 980 join_inferior (); 981 982 exit (0); 983 } 984 case '!': 985 if (attached == 0) 986 { 987 extended_protocol = 1; 988 prepare_resume_reply (own_buf, status, signal); 989 } 990 else 991 { 992 /* We can not use the extended protocol if we are 993 attached, because we can not restart the running 994 program. So return unrecognized. */ 995 own_buf[0] = '\0'; 996 } 997 break; 998 case '?': 999 prepare_resume_reply (own_buf, status, signal); 1000 break; 1001 case 'H': 1002 if (own_buf[1] == 'c' || own_buf[1] == 'g' || own_buf[1] == 's') 1003 { 1004 unsigned long gdb_id, thread_id; 1005 1006 gdb_id = strtoul (&own_buf[2], NULL, 16); 1007 thread_id = gdb_id_to_thread_id (gdb_id); 1008 if (thread_id == 0) 1009 { 1010 write_enn (own_buf); 1011 break; 1012 } 1013 1014 if (own_buf[1] == 'g') 1015 { 1016 general_thread = thread_id; 1017 set_desired_inferior (1); 1018 } 1019 else if (own_buf[1] == 'c') 1020 cont_thread = thread_id; 1021 else if (own_buf[1] == 's') 1022 step_thread = thread_id; 1023 1024 write_ok (own_buf); 1025 } 1026 else 1027 { 1028 /* Silently ignore it so that gdb can extend the protocol 1029 without compatibility headaches. */ 1030 own_buf[0] = '\0'; 1031 } 1032 break; 1033 case 'g': 1034 set_desired_inferior (1); 1035 registers_to_string (own_buf); 1036 break; 1037 case 'G': 1038 set_desired_inferior (1); 1039 registers_from_string (&own_buf[1]); 1040 write_ok (own_buf); 1041 break; 1042 case 'm': 1043 decode_m_packet (&own_buf[1], &mem_addr, &len); 1044 if (read_inferior_memory (mem_addr, mem_buf, len) == 0) 1045 convert_int_to_ascii (mem_buf, own_buf, len); 1046 else 1047 write_enn (own_buf); 1048 break; 1049 case 'M': 1050 decode_M_packet (&own_buf[1], &mem_addr, &len, mem_buf); 1051 if (write_inferior_memory (mem_addr, mem_buf, len) == 0) 1052 write_ok (own_buf); 1053 else 1054 write_enn (own_buf); 1055 break; 1056 case 'X': 1057 if (decode_X_packet (&own_buf[1], packet_len - 1, 1058 &mem_addr, &len, mem_buf) < 0 1059 || write_inferior_memory (mem_addr, mem_buf, len) != 0) 1060 write_enn (own_buf); 1061 else 1062 write_ok (own_buf); 1063 break; 1064 case 'C': 1065 convert_ascii_to_int (own_buf + 1, &sig, 1); 1066 if (target_signal_to_host_p (sig)) 1067 signal = target_signal_to_host (sig); 1068 else 1069 signal = 0; 1070 set_desired_inferior (0); 1071 myresume (0, signal); 1072 signal = mywait (&status, 1); 1073 prepare_resume_reply (own_buf, status, signal); 1074 break; 1075 case 'S': 1076 convert_ascii_to_int (own_buf + 1, &sig, 1); 1077 if (target_signal_to_host_p (sig)) 1078 signal = target_signal_to_host (sig); 1079 else 1080 signal = 0; 1081 set_desired_inferior (0); 1082 myresume (1, signal); 1083 signal = mywait (&status, 1); 1084 prepare_resume_reply (own_buf, status, signal); 1085 break; 1086 case 'c': 1087 set_desired_inferior (0); 1088 myresume (0, 0); 1089 signal = mywait (&status, 1); 1090 prepare_resume_reply (own_buf, status, signal); 1091 break; 1092 case 's': 1093 set_desired_inferior (0); 1094 myresume (1, 0); 1095 signal = mywait (&status, 1); 1096 prepare_resume_reply (own_buf, status, signal); 1097 break; 1098 case 'Z': 1099 { 1100 char *lenptr; 1101 char *dataptr; 1102 CORE_ADDR addr = strtoul (&own_buf[3], &lenptr, 16); 1103 int len = strtol (lenptr + 1, &dataptr, 16); 1104 char type = own_buf[1]; 1105 1106 if (the_target->insert_watchpoint == NULL 1107 || (type < '2' || type > '4')) 1108 { 1109 /* No watchpoint support or not a watchpoint command; 1110 unrecognized either way. */ 1111 own_buf[0] = '\0'; 1112 } 1113 else 1114 { 1115 int res; 1116 1117 res = (*the_target->insert_watchpoint) (type, addr, len); 1118 if (res == 0) 1119 write_ok (own_buf); 1120 else if (res == 1) 1121 /* Unsupported. */ 1122 own_buf[0] = '\0'; 1123 else 1124 write_enn (own_buf); 1125 } 1126 break; 1127 } 1128 case 'z': 1129 { 1130 char *lenptr; 1131 char *dataptr; 1132 CORE_ADDR addr = strtoul (&own_buf[3], &lenptr, 16); 1133 int len = strtol (lenptr + 1, &dataptr, 16); 1134 char type = own_buf[1]; 1135 1136 if (the_target->remove_watchpoint == NULL 1137 || (type < '2' || type > '4')) 1138 { 1139 /* No watchpoint support or not a watchpoint command; 1140 unrecognized either way. */ 1141 own_buf[0] = '\0'; 1142 } 1143 else 1144 { 1145 int res; 1146 1147 res = (*the_target->remove_watchpoint) (type, addr, len); 1148 if (res == 0) 1149 write_ok (own_buf); 1150 else if (res == 1) 1151 /* Unsupported. */ 1152 own_buf[0] = '\0'; 1153 else 1154 write_enn (own_buf); 1155 } 1156 break; 1157 } 1158 case 'k': 1159 fprintf (stderr, "Killing inferior\n"); 1160 kill_inferior (); 1161 /* When using the extended protocol, we start up a new 1162 debugging session. The traditional protocol will 1163 exit instead. */ 1164 if (extended_protocol) 1165 { 1166 write_ok (own_buf); 1167 fprintf (stderr, "GDBserver restarting\n"); 1168 1169 /* Wait till we are at 1st instruction in prog. */ 1170 signal = start_inferior (&argv[2], &status); 1171 goto restart; 1172 break; 1173 } 1174 else 1175 { 1176 exit (0); 1177 break; 1178 } 1179 case 'T': 1180 { 1181 unsigned long gdb_id, thread_id; 1182 1183 gdb_id = strtoul (&own_buf[1], NULL, 16); 1184 thread_id = gdb_id_to_thread_id (gdb_id); 1185 if (thread_id == 0) 1186 { 1187 write_enn (own_buf); 1188 break; 1189 } 1190 1191 if (mythread_alive (thread_id)) 1192 write_ok (own_buf); 1193 else 1194 write_enn (own_buf); 1195 } 1196 break; 1197 case 'R': 1198 /* Restarting the inferior is only supported in the 1199 extended protocol. */ 1200 if (extended_protocol) 1201 { 1202 kill_inferior (); 1203 write_ok (own_buf); 1204 fprintf (stderr, "GDBserver restarting\n"); 1205 1206 /* Wait till we are at 1st instruction in prog. */ 1207 signal = start_inferior (&argv[2], &status); 1208 goto restart; 1209 break; 1210 } 1211 else 1212 { 1213 /* It is a request we don't understand. Respond with an 1214 empty packet so that gdb knows that we don't support this 1215 request. */ 1216 own_buf[0] = '\0'; 1217 break; 1218 } 1219 case 'v': 1220 /* Extended (long) request. */ 1221 handle_v_requests (own_buf, &status, &signal); 1222 break; 1223 default: 1224 /* It is a request we don't understand. Respond with an 1225 empty packet so that gdb knows that we don't support this 1226 request. */ 1227 own_buf[0] = '\0'; 1228 break; 1229 } 1230 1231 if (new_packet_len != -1) 1232 putpkt_binary (own_buf, new_packet_len); 1233 else 1234 putpkt (own_buf); 1235 1236 if (status == 'W') 1237 fprintf (stderr, 1238 "\nChild exited with status %d\n", signal); 1239 if (status == 'X') 1240 fprintf (stderr, "\nChild terminated with signal = 0x%x (%s)\n", 1241 target_signal_to_host (signal), 1242 target_signal_to_name (signal)); 1243 if (status == 'W' || status == 'X') 1244 { 1245 if (extended_protocol) 1246 { 1247 fprintf (stderr, "Killing inferior\n"); 1248 kill_inferior (); 1249 write_ok (own_buf); 1250 fprintf (stderr, "GDBserver restarting\n"); 1251 1252 /* Wait till we are at 1st instruction in prog. */ 1253 signal = start_inferior (&argv[2], &status); 1254 goto restart; 1255 break; 1256 } 1257 else 1258 { 1259 fprintf (stderr, "GDBserver exiting\n"); 1260 exit (0); 1261 } 1262 } 1263 } 1264 1265 /* We come here when getpkt fails. 1266 1267 For the extended remote protocol we exit (and this is the only 1268 way we gracefully exit!). 1269 1270 For the traditional remote protocol close the connection, 1271 and re-open it at the top of the loop. */ 1272 if (extended_protocol) 1273 { 1274 remote_close (); 1275 exit (0); 1276 } 1277 else 1278 { 1279 fprintf (stderr, "Remote side has terminated connection. " 1280 "GDBserver will reopen the connection.\n"); 1281 remote_close (); 1282 } 1283 } 1284} 1285