1 /* Multi-process/thread control for GDB, the GNU debugger. 2 3 Copyright (C) 1986-2013 Free Software Foundation, Inc. 4 5 Contributed by Lynx Real-Time Systems, Inc. Los Gatos, CA. 6 7 This file is part of GDB. 8 9 This program is free software; you can redistribute it and/or modify 10 it under the terms of the GNU General Public License as published by 11 the Free Software Foundation; either version 3 of the License, or 12 (at your option) any later version. 13 14 This program is distributed in the hope that it will be useful, 15 but WITHOUT ANY WARRANTY; without even the implied warranty of 16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 17 GNU General Public License for more details. 18 19 You should have received a copy of the GNU General Public License 20 along with this program. If not, see <http://www.gnu.org/licenses/>. */ 21 22 #include "defs.h" 23 #include "symtab.h" 24 #include "frame.h" 25 #include "inferior.h" 26 #include "environ.h" 27 #include "value.h" 28 #include "target.h" 29 #include "gdbthread.h" 30 #include "exceptions.h" 31 #include "command.h" 32 #include "gdbcmd.h" 33 #include "regcache.h" 34 #include "gdb.h" 35 #include "gdb_string.h" 36 #include "btrace.h" 37 38 #include <ctype.h> 39 #include <sys/types.h> 40 #include <signal.h> 41 #include "ui-out.h" 42 #include "observer.h" 43 #include "annotate.h" 44 #include "cli/cli-decode.h" 45 #include "gdb_regex.h" 46 #include "cli/cli-utils.h" 47 #include "continuations.h" 48 49 /* Definition of struct thread_info exported to gdbthread.h. */ 50 51 /* Prototypes for exported functions. */ 52 53 void _initialize_thread (void); 54 55 /* Prototypes for local functions. */ 56 57 struct thread_info *thread_list = NULL; 58 static int highest_thread_num; 59 60 static void thread_command (char *tidstr, int from_tty); 61 static void thread_apply_all_command (char *, int); 62 static int thread_alive (struct thread_info *); 63 static void info_threads_command (char *, int); 64 static void thread_apply_command (char *, int); 65 static void restore_current_thread (ptid_t); 66 static void prune_threads (void); 67 68 struct thread_info* 69 inferior_thread (void) 70 { 71 struct thread_info *tp = find_thread_ptid (inferior_ptid); 72 gdb_assert (tp); 73 return tp; 74 } 75 76 void 77 delete_step_resume_breakpoint (struct thread_info *tp) 78 { 79 if (tp && tp->control.step_resume_breakpoint) 80 { 81 delete_breakpoint (tp->control.step_resume_breakpoint); 82 tp->control.step_resume_breakpoint = NULL; 83 } 84 } 85 86 void 87 delete_exception_resume_breakpoint (struct thread_info *tp) 88 { 89 if (tp && tp->control.exception_resume_breakpoint) 90 { 91 delete_breakpoint (tp->control.exception_resume_breakpoint); 92 tp->control.exception_resume_breakpoint = NULL; 93 } 94 } 95 96 static void 97 clear_thread_inferior_resources (struct thread_info *tp) 98 { 99 /* NOTE: this will take care of any left-over step_resume breakpoints, 100 but not any user-specified thread-specific breakpoints. We can not 101 delete the breakpoint straight-off, because the inferior might not 102 be stopped at the moment. */ 103 if (tp->control.step_resume_breakpoint) 104 { 105 tp->control.step_resume_breakpoint->disposition = disp_del_at_next_stop; 106 tp->control.step_resume_breakpoint = NULL; 107 } 108 109 if (tp->control.exception_resume_breakpoint) 110 { 111 tp->control.exception_resume_breakpoint->disposition 112 = disp_del_at_next_stop; 113 tp->control.exception_resume_breakpoint = NULL; 114 } 115 116 delete_longjmp_breakpoint_at_next_stop (tp->num); 117 118 bpstat_clear (&tp->control.stop_bpstat); 119 120 btrace_teardown (tp); 121 122 do_all_intermediate_continuations_thread (tp, 1); 123 do_all_continuations_thread (tp, 1); 124 } 125 126 static void 127 free_thread (struct thread_info *tp) 128 { 129 if (tp->private) 130 { 131 if (tp->private_dtor) 132 tp->private_dtor (tp->private); 133 else 134 xfree (tp->private); 135 } 136 137 xfree (tp->name); 138 xfree (tp); 139 } 140 141 void 142 init_thread_list (void) 143 { 144 struct thread_info *tp, *tpnext; 145 146 highest_thread_num = 0; 147 148 if (!thread_list) 149 return; 150 151 for (tp = thread_list; tp; tp = tpnext) 152 { 153 tpnext = tp->next; 154 free_thread (tp); 155 } 156 157 thread_list = NULL; 158 } 159 160 /* Allocate a new thread with target id PTID and add it to the thread 161 list. */ 162 163 static struct thread_info * 164 new_thread (ptid_t ptid) 165 { 166 struct thread_info *tp; 167 168 tp = xcalloc (1, sizeof (*tp)); 169 170 tp->ptid = ptid; 171 tp->num = ++highest_thread_num; 172 tp->next = thread_list; 173 thread_list = tp; 174 175 /* Nothing to follow yet. */ 176 tp->pending_follow.kind = TARGET_WAITKIND_SPURIOUS; 177 tp->state = THREAD_STOPPED; 178 179 return tp; 180 } 181 182 struct thread_info * 183 add_thread_silent (ptid_t ptid) 184 { 185 struct thread_info *tp; 186 187 tp = find_thread_ptid (ptid); 188 if (tp) 189 /* Found an old thread with the same id. It has to be dead, 190 otherwise we wouldn't be adding a new thread with the same id. 191 The OS is reusing this id --- delete it, and recreate a new 192 one. */ 193 { 194 /* In addition to deleting the thread, if this is the current 195 thread, then we need to take care that delete_thread doesn't 196 really delete the thread if it is inferior_ptid. Create a 197 new template thread in the list with an invalid ptid, switch 198 to it, delete the original thread, reset the new thread's 199 ptid, and switch to it. */ 200 201 if (ptid_equal (inferior_ptid, ptid)) 202 { 203 tp = new_thread (null_ptid); 204 205 /* Make switch_to_thread not read from the thread. */ 206 tp->state = THREAD_EXITED; 207 switch_to_thread (null_ptid); 208 209 /* Now we can delete it. */ 210 delete_thread (ptid); 211 212 /* Now reset its ptid, and reswitch inferior_ptid to it. */ 213 tp->ptid = ptid; 214 tp->state = THREAD_STOPPED; 215 switch_to_thread (ptid); 216 217 observer_notify_new_thread (tp); 218 219 /* All done. */ 220 return tp; 221 } 222 else 223 /* Just go ahead and delete it. */ 224 delete_thread (ptid); 225 } 226 227 tp = new_thread (ptid); 228 observer_notify_new_thread (tp); 229 230 return tp; 231 } 232 233 struct thread_info * 234 add_thread_with_info (ptid_t ptid, struct private_thread_info *private) 235 { 236 struct thread_info *result = add_thread_silent (ptid); 237 238 result->private = private; 239 240 if (print_thread_events) 241 printf_unfiltered (_("[New %s]\n"), target_pid_to_str (ptid)); 242 243 annotate_new_thread (); 244 return result; 245 } 246 247 struct thread_info * 248 add_thread (ptid_t ptid) 249 { 250 return add_thread_with_info (ptid, NULL); 251 } 252 253 /* Delete thread PTID. If SILENT, don't notify the observer of this 254 exit. */ 255 static void 256 delete_thread_1 (ptid_t ptid, int silent) 257 { 258 struct thread_info *tp, *tpprev; 259 260 tpprev = NULL; 261 262 for (tp = thread_list; tp; tpprev = tp, tp = tp->next) 263 if (ptid_equal (tp->ptid, ptid)) 264 break; 265 266 if (!tp) 267 return; 268 269 /* If this is the current thread, or there's code out there that 270 relies on it existing (refcount > 0) we can't delete yet. Mark 271 it as exited, and notify it. */ 272 if (tp->refcount > 0 273 || ptid_equal (tp->ptid, inferior_ptid)) 274 { 275 if (tp->state != THREAD_EXITED) 276 { 277 observer_notify_thread_exit (tp, silent); 278 279 /* Tag it as exited. */ 280 tp->state = THREAD_EXITED; 281 282 /* Clear breakpoints, etc. associated with this thread. */ 283 clear_thread_inferior_resources (tp); 284 } 285 286 /* Will be really deleted some other time. */ 287 return; 288 } 289 290 /* Notify thread exit, but only if we haven't already. */ 291 if (tp->state != THREAD_EXITED) 292 observer_notify_thread_exit (tp, silent); 293 294 /* Tag it as exited. */ 295 tp->state = THREAD_EXITED; 296 clear_thread_inferior_resources (tp); 297 298 if (tpprev) 299 tpprev->next = tp->next; 300 else 301 thread_list = tp->next; 302 303 free_thread (tp); 304 } 305 306 /* Delete thread PTID and notify of thread exit. If this is 307 inferior_ptid, don't actually delete it, but tag it as exited and 308 do the notification. If PTID is the user selected thread, clear 309 it. */ 310 void 311 delete_thread (ptid_t ptid) 312 { 313 delete_thread_1 (ptid, 0 /* not silent */); 314 } 315 316 void 317 delete_thread_silent (ptid_t ptid) 318 { 319 delete_thread_1 (ptid, 1 /* silent */); 320 } 321 322 struct thread_info * 323 find_thread_id (int num) 324 { 325 struct thread_info *tp; 326 327 for (tp = thread_list; tp; tp = tp->next) 328 if (tp->num == num) 329 return tp; 330 331 return NULL; 332 } 333 334 /* Find a thread_info by matching PTID. */ 335 struct thread_info * 336 find_thread_ptid (ptid_t ptid) 337 { 338 struct thread_info *tp; 339 340 for (tp = thread_list; tp; tp = tp->next) 341 if (ptid_equal (tp->ptid, ptid)) 342 return tp; 343 344 return NULL; 345 } 346 347 /* 348 * Thread iterator function. 349 * 350 * Calls a callback function once for each thread, so long as 351 * the callback function returns false. If the callback function 352 * returns true, the iteration will end and the current thread 353 * will be returned. This can be useful for implementing a 354 * search for a thread with arbitrary attributes, or for applying 355 * some operation to every thread. 356 * 357 * FIXME: some of the existing functionality, such as 358 * "Thread apply all", might be rewritten using this functionality. 359 */ 360 361 struct thread_info * 362 iterate_over_threads (int (*callback) (struct thread_info *, void *), 363 void *data) 364 { 365 struct thread_info *tp, *next; 366 367 for (tp = thread_list; tp; tp = next) 368 { 369 next = tp->next; 370 if ((*callback) (tp, data)) 371 return tp; 372 } 373 374 return NULL; 375 } 376 377 int 378 thread_count (void) 379 { 380 int result = 0; 381 struct thread_info *tp; 382 383 for (tp = thread_list; tp; tp = tp->next) 384 ++result; 385 386 return result; 387 } 388 389 int 390 valid_thread_id (int num) 391 { 392 struct thread_info *tp; 393 394 for (tp = thread_list; tp; tp = tp->next) 395 if (tp->num == num) 396 return 1; 397 398 return 0; 399 } 400 401 int 402 pid_to_thread_id (ptid_t ptid) 403 { 404 struct thread_info *tp; 405 406 for (tp = thread_list; tp; tp = tp->next) 407 if (ptid_equal (tp->ptid, ptid)) 408 return tp->num; 409 410 return 0; 411 } 412 413 ptid_t 414 thread_id_to_pid (int num) 415 { 416 struct thread_info *thread = find_thread_id (num); 417 418 if (thread) 419 return thread->ptid; 420 else 421 return pid_to_ptid (-1); 422 } 423 424 int 425 in_thread_list (ptid_t ptid) 426 { 427 struct thread_info *tp; 428 429 for (tp = thread_list; tp; tp = tp->next) 430 if (ptid_equal (tp->ptid, ptid)) 431 return 1; 432 433 return 0; /* Never heard of 'im. */ 434 } 435 436 /* Finds the first thread of the inferior given by PID. If PID is -1, 437 return the first thread in the list. */ 438 439 struct thread_info * 440 first_thread_of_process (int pid) 441 { 442 struct thread_info *tp, *ret = NULL; 443 444 for (tp = thread_list; tp; tp = tp->next) 445 if (pid == -1 || ptid_get_pid (tp->ptid) == pid) 446 if (ret == NULL || tp->num < ret->num) 447 ret = tp; 448 449 return ret; 450 } 451 452 struct thread_info * 453 any_thread_of_process (int pid) 454 { 455 struct thread_info *tp; 456 457 for (tp = thread_list; tp; tp = tp->next) 458 if (ptid_get_pid (tp->ptid) == pid) 459 return tp; 460 461 return NULL; 462 } 463 464 struct thread_info * 465 any_live_thread_of_process (int pid) 466 { 467 struct thread_info *tp; 468 struct thread_info *tp_executing = NULL; 469 470 for (tp = thread_list; tp; tp = tp->next) 471 if (tp->state != THREAD_EXITED && ptid_get_pid (tp->ptid) == pid) 472 { 473 if (tp->executing) 474 tp_executing = tp; 475 else 476 return tp; 477 } 478 479 return tp_executing; 480 } 481 482 /* Print a list of thread ids currently known, and the total number of 483 threads. To be used from within catch_errors. */ 484 static int 485 do_captured_list_thread_ids (struct ui_out *uiout, void *arg) 486 { 487 struct thread_info *tp; 488 int num = 0; 489 struct cleanup *cleanup_chain; 490 int current_thread = -1; 491 492 update_thread_list (); 493 494 cleanup_chain = make_cleanup_ui_out_tuple_begin_end (uiout, "thread-ids"); 495 496 for (tp = thread_list; tp; tp = tp->next) 497 { 498 if (tp->state == THREAD_EXITED) 499 continue; 500 501 if (ptid_equal (tp->ptid, inferior_ptid)) 502 current_thread = tp->num; 503 504 num++; 505 ui_out_field_int (uiout, "thread-id", tp->num); 506 } 507 508 do_cleanups (cleanup_chain); 509 510 if (current_thread != -1) 511 ui_out_field_int (uiout, "current-thread-id", current_thread); 512 ui_out_field_int (uiout, "number-of-threads", num); 513 return GDB_RC_OK; 514 } 515 516 /* Official gdblib interface function to get a list of thread ids and 517 the total number. */ 518 enum gdb_rc 519 gdb_list_thread_ids (struct ui_out *uiout, char **error_message) 520 { 521 if (catch_exceptions_with_msg (uiout, do_captured_list_thread_ids, NULL, 522 error_message, RETURN_MASK_ALL) < 0) 523 return GDB_RC_FAIL; 524 return GDB_RC_OK; 525 } 526 527 /* Return true if TP is an active thread. */ 528 static int 529 thread_alive (struct thread_info *tp) 530 { 531 if (tp->state == THREAD_EXITED) 532 return 0; 533 if (!target_thread_alive (tp->ptid)) 534 return 0; 535 return 1; 536 } 537 538 static void 539 prune_threads (void) 540 { 541 struct thread_info *tp, *next; 542 543 for (tp = thread_list; tp; tp = next) 544 { 545 next = tp->next; 546 if (!thread_alive (tp)) 547 delete_thread (tp->ptid); 548 } 549 } 550 551 void 552 thread_change_ptid (ptid_t old_ptid, ptid_t new_ptid) 553 { 554 struct inferior *inf; 555 struct thread_info *tp; 556 557 /* It can happen that what we knew as the target inferior id 558 changes. E.g, target remote may only discover the remote process 559 pid after adding the inferior to GDB's list. */ 560 inf = find_inferior_pid (ptid_get_pid (old_ptid)); 561 inf->pid = ptid_get_pid (new_ptid); 562 563 tp = find_thread_ptid (old_ptid); 564 tp->ptid = new_ptid; 565 566 observer_notify_thread_ptid_changed (old_ptid, new_ptid); 567 } 568 569 void 570 set_running (ptid_t ptid, int running) 571 { 572 struct thread_info *tp; 573 int all = ptid_equal (ptid, minus_one_ptid); 574 575 /* We try not to notify the observer if no thread has actually changed 576 the running state -- merely to reduce the number of messages to 577 frontend. Frontend is supposed to handle multiple *running just fine. */ 578 if (all || ptid_is_pid (ptid)) 579 { 580 int any_started = 0; 581 582 for (tp = thread_list; tp; tp = tp->next) 583 if (all || ptid_get_pid (tp->ptid) == ptid_get_pid (ptid)) 584 { 585 if (tp->state == THREAD_EXITED) 586 continue; 587 if (running && tp->state == THREAD_STOPPED) 588 any_started = 1; 589 tp->state = running ? THREAD_RUNNING : THREAD_STOPPED; 590 } 591 if (any_started) 592 observer_notify_target_resumed (ptid); 593 } 594 else 595 { 596 int started = 0; 597 598 tp = find_thread_ptid (ptid); 599 gdb_assert (tp); 600 gdb_assert (tp->state != THREAD_EXITED); 601 if (running && tp->state == THREAD_STOPPED) 602 started = 1; 603 tp->state = running ? THREAD_RUNNING : THREAD_STOPPED; 604 if (started) 605 observer_notify_target_resumed (ptid); 606 } 607 } 608 609 static int 610 is_thread_state (ptid_t ptid, enum thread_state state) 611 { 612 struct thread_info *tp; 613 614 tp = find_thread_ptid (ptid); 615 gdb_assert (tp); 616 return tp->state == state; 617 } 618 619 int 620 is_stopped (ptid_t ptid) 621 { 622 return is_thread_state (ptid, THREAD_STOPPED); 623 } 624 625 int 626 is_exited (ptid_t ptid) 627 { 628 return is_thread_state (ptid, THREAD_EXITED); 629 } 630 631 int 632 is_running (ptid_t ptid) 633 { 634 return is_thread_state (ptid, THREAD_RUNNING); 635 } 636 637 int 638 any_running (void) 639 { 640 struct thread_info *tp; 641 642 for (tp = thread_list; tp; tp = tp->next) 643 if (tp->state == THREAD_RUNNING) 644 return 1; 645 646 return 0; 647 } 648 649 int 650 is_executing (ptid_t ptid) 651 { 652 struct thread_info *tp; 653 654 tp = find_thread_ptid (ptid); 655 gdb_assert (tp); 656 return tp->executing; 657 } 658 659 void 660 set_executing (ptid_t ptid, int executing) 661 { 662 struct thread_info *tp; 663 int all = ptid_equal (ptid, minus_one_ptid); 664 665 if (all || ptid_is_pid (ptid)) 666 { 667 for (tp = thread_list; tp; tp = tp->next) 668 if (all || ptid_get_pid (tp->ptid) == ptid_get_pid (ptid)) 669 tp->executing = executing; 670 } 671 else 672 { 673 tp = find_thread_ptid (ptid); 674 gdb_assert (tp); 675 tp->executing = executing; 676 } 677 } 678 679 void 680 set_stop_requested (ptid_t ptid, int stop) 681 { 682 struct thread_info *tp; 683 int all = ptid_equal (ptid, minus_one_ptid); 684 685 if (all || ptid_is_pid (ptid)) 686 { 687 for (tp = thread_list; tp; tp = tp->next) 688 if (all || ptid_get_pid (tp->ptid) == ptid_get_pid (ptid)) 689 tp->stop_requested = stop; 690 } 691 else 692 { 693 tp = find_thread_ptid (ptid); 694 gdb_assert (tp); 695 tp->stop_requested = stop; 696 } 697 698 /* Call the stop requested observer so other components of GDB can 699 react to this request. */ 700 if (stop) 701 observer_notify_thread_stop_requested (ptid); 702 } 703 704 void 705 finish_thread_state (ptid_t ptid) 706 { 707 struct thread_info *tp; 708 int all; 709 int any_started = 0; 710 711 all = ptid_equal (ptid, minus_one_ptid); 712 713 if (all || ptid_is_pid (ptid)) 714 { 715 for (tp = thread_list; tp; tp = tp->next) 716 { 717 if (tp->state == THREAD_EXITED) 718 continue; 719 if (all || ptid_get_pid (ptid) == ptid_get_pid (tp->ptid)) 720 { 721 if (tp->executing && tp->state == THREAD_STOPPED) 722 any_started = 1; 723 tp->state = tp->executing ? THREAD_RUNNING : THREAD_STOPPED; 724 } 725 } 726 } 727 else 728 { 729 tp = find_thread_ptid (ptid); 730 gdb_assert (tp); 731 if (tp->state != THREAD_EXITED) 732 { 733 if (tp->executing && tp->state == THREAD_STOPPED) 734 any_started = 1; 735 tp->state = tp->executing ? THREAD_RUNNING : THREAD_STOPPED; 736 } 737 } 738 739 if (any_started) 740 observer_notify_target_resumed (ptid); 741 } 742 743 void 744 finish_thread_state_cleanup (void *arg) 745 { 746 ptid_t *ptid_p = arg; 747 748 gdb_assert (arg); 749 750 finish_thread_state (*ptid_p); 751 } 752 753 /* Prints the list of threads and their details on UIOUT. 754 This is a version of 'info_threads_command' suitable for 755 use from MI. 756 If REQUESTED_THREAD is not -1, it's the GDB id of the thread 757 that should be printed. Otherwise, all threads are 758 printed. 759 If PID is not -1, only print threads from the process PID. 760 Otherwise, threads from all attached PIDs are printed. 761 If both REQUESTED_THREAD and PID are not -1, then the thread 762 is printed if it belongs to the specified process. Otherwise, 763 an error is raised. */ 764 void 765 print_thread_info (struct ui_out *uiout, char *requested_threads, int pid) 766 { 767 struct thread_info *tp; 768 ptid_t current_ptid; 769 struct cleanup *old_chain; 770 char *extra_info, *name, *target_id; 771 int current_thread = -1; 772 773 update_thread_list (); 774 current_ptid = inferior_ptid; 775 776 /* We'll be switching threads temporarily. */ 777 old_chain = make_cleanup_restore_current_thread (); 778 779 /* For backward compatibility, we make a list for MI. A table is 780 preferable for the CLI, though, because it shows table 781 headers. */ 782 if (ui_out_is_mi_like_p (uiout)) 783 make_cleanup_ui_out_list_begin_end (uiout, "threads"); 784 else 785 { 786 int n_threads = 0; 787 788 for (tp = thread_list; tp; tp = tp->next) 789 { 790 if (!number_is_in_list (requested_threads, tp->num)) 791 continue; 792 793 if (pid != -1 && PIDGET (tp->ptid) != pid) 794 continue; 795 796 if (tp->state == THREAD_EXITED) 797 continue; 798 799 ++n_threads; 800 } 801 802 if (n_threads == 0) 803 { 804 if (requested_threads == NULL || *requested_threads == '\0') 805 ui_out_message (uiout, 0, _("No threads.\n")); 806 else 807 ui_out_message (uiout, 0, _("No threads match '%s'.\n"), 808 requested_threads); 809 do_cleanups (old_chain); 810 return; 811 } 812 813 make_cleanup_ui_out_table_begin_end (uiout, 4, n_threads, "threads"); 814 815 ui_out_table_header (uiout, 1, ui_left, "current", ""); 816 ui_out_table_header (uiout, 4, ui_left, "id", "Id"); 817 ui_out_table_header (uiout, 17, ui_left, "target-id", "Target Id"); 818 ui_out_table_header (uiout, 1, ui_left, "frame", "Frame"); 819 ui_out_table_body (uiout); 820 } 821 822 for (tp = thread_list; tp; tp = tp->next) 823 { 824 struct cleanup *chain2; 825 int core; 826 827 if (!number_is_in_list (requested_threads, tp->num)) 828 continue; 829 830 if (pid != -1 && PIDGET (tp->ptid) != pid) 831 { 832 if (requested_threads != NULL && *requested_threads != '\0') 833 error (_("Requested thread not found in requested process")); 834 continue; 835 } 836 837 if (ptid_equal (tp->ptid, current_ptid)) 838 current_thread = tp->num; 839 840 if (tp->state == THREAD_EXITED) 841 continue; 842 843 chain2 = make_cleanup_ui_out_tuple_begin_end (uiout, NULL); 844 845 if (ui_out_is_mi_like_p (uiout)) 846 { 847 /* Compatibility. */ 848 if (ptid_equal (tp->ptid, current_ptid)) 849 ui_out_text (uiout, "* "); 850 else 851 ui_out_text (uiout, " "); 852 } 853 else 854 { 855 if (ptid_equal (tp->ptid, current_ptid)) 856 ui_out_field_string (uiout, "current", "*"); 857 else 858 ui_out_field_skip (uiout, "current"); 859 } 860 861 ui_out_field_int (uiout, "id", tp->num); 862 863 /* For the CLI, we stuff everything into the target-id field. 864 This is a gross hack to make the output come out looking 865 correct. The underlying problem here is that ui-out has no 866 way to specify that a field's space allocation should be 867 shared by several fields. For MI, we do the right thing 868 instead. */ 869 870 target_id = target_pid_to_str (tp->ptid); 871 extra_info = target_extra_thread_info (tp); 872 name = tp->name ? tp->name : target_thread_name (tp); 873 874 if (ui_out_is_mi_like_p (uiout)) 875 { 876 ui_out_field_string (uiout, "target-id", target_id); 877 if (extra_info) 878 ui_out_field_string (uiout, "details", extra_info); 879 if (name) 880 ui_out_field_string (uiout, "name", name); 881 } 882 else 883 { 884 struct cleanup *str_cleanup; 885 char *contents; 886 887 if (extra_info && name) 888 contents = xstrprintf ("%s \"%s\" (%s)", target_id, 889 name, extra_info); 890 else if (extra_info) 891 contents = xstrprintf ("%s (%s)", target_id, extra_info); 892 else if (name) 893 contents = xstrprintf ("%s \"%s\"", target_id, name); 894 else 895 contents = xstrdup (target_id); 896 str_cleanup = make_cleanup (xfree, contents); 897 898 ui_out_field_string (uiout, "target-id", contents); 899 do_cleanups (str_cleanup); 900 } 901 902 if (tp->state == THREAD_RUNNING) 903 ui_out_text (uiout, "(running)\n"); 904 else 905 { 906 /* The switch below puts us at the top of the stack (leaf 907 frame). */ 908 switch_to_thread (tp->ptid); 909 print_stack_frame (get_selected_frame (NULL), 910 /* For MI output, print frame level. */ 911 ui_out_is_mi_like_p (uiout), 912 LOCATION); 913 } 914 915 if (ui_out_is_mi_like_p (uiout)) 916 { 917 char *state = "stopped"; 918 919 if (tp->state == THREAD_RUNNING) 920 state = "running"; 921 ui_out_field_string (uiout, "state", state); 922 } 923 924 core = target_core_of_thread (tp->ptid); 925 if (ui_out_is_mi_like_p (uiout) && core != -1) 926 ui_out_field_int (uiout, "core", core); 927 928 do_cleanups (chain2); 929 } 930 931 /* Restores the current thread and the frame selected before 932 the "info threads" command. */ 933 do_cleanups (old_chain); 934 935 if (pid == -1 && requested_threads == NULL) 936 { 937 gdb_assert (current_thread != -1 938 || !thread_list 939 || ptid_equal (inferior_ptid, null_ptid)); 940 if (current_thread != -1 && ui_out_is_mi_like_p (uiout)) 941 ui_out_field_int (uiout, "current-thread-id", current_thread); 942 943 if (current_thread != -1 && is_exited (current_ptid)) 944 ui_out_message (uiout, 0, "\n\ 945 The current thread <Thread ID %d> has terminated. See `help thread'.\n", 946 current_thread); 947 else if (thread_list 948 && current_thread == -1 949 && ptid_equal (current_ptid, null_ptid)) 950 ui_out_message (uiout, 0, "\n\ 951 No selected thread. See `help thread'.\n"); 952 } 953 } 954 955 /* Print information about currently known threads 956 957 Optional ARG is a thread id, or list of thread ids. 958 959 Note: this has the drawback that it _really_ switches 960 threads, which frees the frame cache. A no-side 961 effects info-threads command would be nicer. */ 962 963 static void 964 info_threads_command (char *arg, int from_tty) 965 { 966 print_thread_info (current_uiout, arg, -1); 967 } 968 969 /* Switch from one thread to another. */ 970 971 void 972 switch_to_thread (ptid_t ptid) 973 { 974 /* Switch the program space as well, if we can infer it from the now 975 current thread. Otherwise, it's up to the caller to select the 976 space it wants. */ 977 if (!ptid_equal (ptid, null_ptid)) 978 { 979 struct inferior *inf; 980 981 inf = find_inferior_pid (ptid_get_pid (ptid)); 982 gdb_assert (inf != NULL); 983 set_current_program_space (inf->pspace); 984 set_current_inferior (inf); 985 } 986 987 if (ptid_equal (ptid, inferior_ptid)) 988 return; 989 990 inferior_ptid = ptid; 991 reinit_frame_cache (); 992 993 /* We don't check for is_stopped, because we're called at times 994 while in the TARGET_RUNNING state, e.g., while handling an 995 internal event. */ 996 if (!ptid_equal (inferior_ptid, null_ptid) 997 && !is_exited (ptid) 998 && !is_executing (ptid)) 999 stop_pc = regcache_read_pc (get_thread_regcache (ptid)); 1000 else 1001 stop_pc = ~(CORE_ADDR) 0; 1002 } 1003 1004 static void 1005 restore_current_thread (ptid_t ptid) 1006 { 1007 switch_to_thread (ptid); 1008 } 1009 1010 static void 1011 restore_selected_frame (struct frame_id a_frame_id, int frame_level) 1012 { 1013 struct frame_info *frame = NULL; 1014 int count; 1015 1016 /* This means there was no selected frame. */ 1017 if (frame_level == -1) 1018 { 1019 select_frame (NULL); 1020 return; 1021 } 1022 1023 gdb_assert (frame_level >= 0); 1024 1025 /* Restore by level first, check if the frame id is the same as 1026 expected. If that fails, try restoring by frame id. If that 1027 fails, nothing to do, just warn the user. */ 1028 1029 count = frame_level; 1030 frame = find_relative_frame (get_current_frame (), &count); 1031 if (count == 0 1032 && frame != NULL 1033 /* The frame ids must match - either both valid or both outer_frame_id. 1034 The latter case is not failsafe, but since it's highly unlikely 1035 the search by level finds the wrong frame, it's 99.9(9)% of 1036 the time (for all practical purposes) safe. */ 1037 && frame_id_eq (get_frame_id (frame), a_frame_id)) 1038 { 1039 /* Cool, all is fine. */ 1040 select_frame (frame); 1041 return; 1042 } 1043 1044 frame = frame_find_by_id (a_frame_id); 1045 if (frame != NULL) 1046 { 1047 /* Cool, refound it. */ 1048 select_frame (frame); 1049 return; 1050 } 1051 1052 /* Nothing else to do, the frame layout really changed. Select the 1053 innermost stack frame. */ 1054 select_frame (get_current_frame ()); 1055 1056 /* Warn the user. */ 1057 if (frame_level > 0 && !ui_out_is_mi_like_p (current_uiout)) 1058 { 1059 warning (_("Couldn't restore frame #%d in " 1060 "current thread, at reparsed frame #0\n"), 1061 frame_level); 1062 /* For MI, we should probably have a notification about 1063 current frame change. But this error is not very 1064 likely, so don't bother for now. */ 1065 print_stack_frame (get_selected_frame (NULL), 1, SRC_LINE); 1066 } 1067 } 1068 1069 struct current_thread_cleanup 1070 { 1071 ptid_t inferior_ptid; 1072 struct frame_id selected_frame_id; 1073 int selected_frame_level; 1074 int was_stopped; 1075 int inf_id; 1076 int was_removable; 1077 }; 1078 1079 static void 1080 do_restore_current_thread_cleanup (void *arg) 1081 { 1082 struct thread_info *tp; 1083 struct current_thread_cleanup *old = arg; 1084 1085 tp = find_thread_ptid (old->inferior_ptid); 1086 1087 /* If the previously selected thread belonged to a process that has 1088 in the mean time been deleted (due to normal exit, detach, etc.), 1089 then don't revert back to it, but instead simply drop back to no 1090 thread selected. */ 1091 if (tp 1092 && find_inferior_pid (ptid_get_pid (tp->ptid)) != NULL) 1093 restore_current_thread (old->inferior_ptid); 1094 else 1095 { 1096 restore_current_thread (null_ptid); 1097 set_current_inferior (find_inferior_id (old->inf_id)); 1098 } 1099 1100 /* The running state of the originally selected thread may have 1101 changed, so we have to recheck it here. */ 1102 if (!ptid_equal (inferior_ptid, null_ptid) 1103 && old->was_stopped 1104 && is_stopped (inferior_ptid) 1105 && target_has_registers 1106 && target_has_stack 1107 && target_has_memory) 1108 restore_selected_frame (old->selected_frame_id, 1109 old->selected_frame_level); 1110 } 1111 1112 static void 1113 restore_current_thread_cleanup_dtor (void *arg) 1114 { 1115 struct current_thread_cleanup *old = arg; 1116 struct thread_info *tp; 1117 struct inferior *inf; 1118 1119 tp = find_thread_ptid (old->inferior_ptid); 1120 if (tp) 1121 tp->refcount--; 1122 inf = find_inferior_id (old->inf_id); 1123 if (inf != NULL) 1124 inf->removable = old->was_removable; 1125 xfree (old); 1126 } 1127 1128 struct cleanup * 1129 make_cleanup_restore_current_thread (void) 1130 { 1131 struct thread_info *tp; 1132 struct frame_info *frame; 1133 struct current_thread_cleanup *old; 1134 1135 old = xmalloc (sizeof (struct current_thread_cleanup)); 1136 old->inferior_ptid = inferior_ptid; 1137 old->inf_id = current_inferior ()->num; 1138 old->was_removable = current_inferior ()->removable; 1139 1140 if (!ptid_equal (inferior_ptid, null_ptid)) 1141 { 1142 old->was_stopped = is_stopped (inferior_ptid); 1143 if (old->was_stopped 1144 && target_has_registers 1145 && target_has_stack 1146 && target_has_memory) 1147 { 1148 /* When processing internal events, there might not be a 1149 selected frame. If we naively call get_selected_frame 1150 here, then we can end up reading debuginfo for the 1151 current frame, but we don't generally need the debuginfo 1152 at this point. */ 1153 frame = get_selected_frame_if_set (); 1154 } 1155 else 1156 frame = NULL; 1157 1158 old->selected_frame_id = get_frame_id (frame); 1159 old->selected_frame_level = frame_relative_level (frame); 1160 1161 tp = find_thread_ptid (inferior_ptid); 1162 if (tp) 1163 tp->refcount++; 1164 } 1165 1166 current_inferior ()->removable = 0; 1167 1168 return make_cleanup_dtor (do_restore_current_thread_cleanup, old, 1169 restore_current_thread_cleanup_dtor); 1170 } 1171 1172 /* Apply a GDB command to a list of threads. List syntax is a whitespace 1173 seperated list of numbers, or ranges, or the keyword `all'. Ranges consist 1174 of two numbers seperated by a hyphen. Examples: 1175 1176 thread apply 1 2 7 4 backtrace Apply backtrace cmd to threads 1,2,7,4 1177 thread apply 2-7 9 p foo(1) Apply p foo(1) cmd to threads 2->7 & 9 1178 thread apply all p x/i $pc Apply x/i $pc cmd to all threads. */ 1179 1180 static void 1181 thread_apply_all_command (char *cmd, int from_tty) 1182 { 1183 struct thread_info *tp; 1184 struct cleanup *old_chain; 1185 char *saved_cmd; 1186 1187 if (cmd == NULL || *cmd == '\000') 1188 error (_("Please specify a command following the thread ID list")); 1189 1190 update_thread_list (); 1191 1192 old_chain = make_cleanup_restore_current_thread (); 1193 1194 /* Save a copy of the command in case it is clobbered by 1195 execute_command. */ 1196 saved_cmd = xstrdup (cmd); 1197 make_cleanup (xfree, saved_cmd); 1198 for (tp = thread_list; tp; tp = tp->next) 1199 if (thread_alive (tp)) 1200 { 1201 switch_to_thread (tp->ptid); 1202 1203 printf_filtered (_("\nThread %d (%s):\n"), 1204 tp->num, target_pid_to_str (inferior_ptid)); 1205 execute_command (cmd, from_tty); 1206 strcpy (cmd, saved_cmd); /* Restore exact command used 1207 previously. */ 1208 } 1209 1210 do_cleanups (old_chain); 1211 } 1212 1213 static void 1214 thread_apply_command (char *tidlist, int from_tty) 1215 { 1216 char *cmd; 1217 struct cleanup *old_chain; 1218 char *saved_cmd; 1219 struct get_number_or_range_state state; 1220 1221 if (tidlist == NULL || *tidlist == '\000') 1222 error (_("Please specify a thread ID list")); 1223 1224 for (cmd = tidlist; *cmd != '\000' && !isalpha (*cmd); cmd++); 1225 1226 if (*cmd == '\000') 1227 error (_("Please specify a command following the thread ID list")); 1228 1229 /* Save a copy of the command in case it is clobbered by 1230 execute_command. */ 1231 saved_cmd = xstrdup (cmd); 1232 old_chain = make_cleanup (xfree, saved_cmd); 1233 1234 init_number_or_range (&state, tidlist); 1235 while (!state.finished && state.string < cmd) 1236 { 1237 struct thread_info *tp; 1238 int start; 1239 1240 start = get_number_or_range (&state); 1241 1242 make_cleanup_restore_current_thread (); 1243 1244 tp = find_thread_id (start); 1245 1246 if (!tp) 1247 warning (_("Unknown thread %d."), start); 1248 else if (!thread_alive (tp)) 1249 warning (_("Thread %d has terminated."), start); 1250 else 1251 { 1252 switch_to_thread (tp->ptid); 1253 1254 printf_filtered (_("\nThread %d (%s):\n"), tp->num, 1255 target_pid_to_str (inferior_ptid)); 1256 execute_command (cmd, from_tty); 1257 1258 /* Restore exact command used previously. */ 1259 strcpy (cmd, saved_cmd); 1260 } 1261 } 1262 1263 do_cleanups (old_chain); 1264 } 1265 1266 /* Switch to the specified thread. Will dispatch off to thread_apply_command 1267 if prefix of arg is `apply'. */ 1268 1269 static void 1270 thread_command (char *tidstr, int from_tty) 1271 { 1272 if (!tidstr) 1273 { 1274 if (ptid_equal (inferior_ptid, null_ptid)) 1275 error (_("No thread selected")); 1276 1277 if (target_has_stack) 1278 { 1279 if (is_exited (inferior_ptid)) 1280 printf_filtered (_("[Current thread is %d (%s) (exited)]\n"), 1281 pid_to_thread_id (inferior_ptid), 1282 target_pid_to_str (inferior_ptid)); 1283 else 1284 printf_filtered (_("[Current thread is %d (%s)]\n"), 1285 pid_to_thread_id (inferior_ptid), 1286 target_pid_to_str (inferior_ptid)); 1287 } 1288 else 1289 error (_("No stack.")); 1290 return; 1291 } 1292 1293 gdb_thread_select (current_uiout, tidstr, NULL); 1294 } 1295 1296 /* Implementation of `thread name'. */ 1297 1298 static void 1299 thread_name_command (char *arg, int from_tty) 1300 { 1301 struct thread_info *info; 1302 1303 if (ptid_equal (inferior_ptid, null_ptid)) 1304 error (_("No thread selected")); 1305 1306 arg = skip_spaces (arg); 1307 1308 info = inferior_thread (); 1309 xfree (info->name); 1310 info->name = arg ? xstrdup (arg) : NULL; 1311 } 1312 1313 /* Find thread ids with a name, target pid, or extra info matching ARG. */ 1314 1315 static void 1316 thread_find_command (char *arg, int from_tty) 1317 { 1318 struct thread_info *tp; 1319 char *tmp; 1320 unsigned long match = 0; 1321 1322 if (arg == NULL || *arg == '\0') 1323 error (_("Command requires an argument.")); 1324 1325 tmp = re_comp (arg); 1326 if (tmp != 0) 1327 error (_("Invalid regexp (%s): %s"), tmp, arg); 1328 1329 update_thread_list (); 1330 for (tp = thread_list; tp; tp = tp->next) 1331 { 1332 if (tp->name != NULL && re_exec (tp->name)) 1333 { 1334 printf_filtered (_("Thread %d has name '%s'\n"), 1335 tp->num, tp->name); 1336 match++; 1337 } 1338 1339 tmp = target_thread_name (tp); 1340 if (tmp != NULL && re_exec (tmp)) 1341 { 1342 printf_filtered (_("Thread %d has target name '%s'\n"), 1343 tp->num, tmp); 1344 match++; 1345 } 1346 1347 tmp = target_pid_to_str (tp->ptid); 1348 if (tmp != NULL && re_exec (tmp)) 1349 { 1350 printf_filtered (_("Thread %d has target id '%s'\n"), 1351 tp->num, tmp); 1352 match++; 1353 } 1354 1355 tmp = target_extra_thread_info (tp); 1356 if (tmp != NULL && re_exec (tmp)) 1357 { 1358 printf_filtered (_("Thread %d has extra info '%s'\n"), 1359 tp->num, tmp); 1360 match++; 1361 } 1362 } 1363 if (!match) 1364 printf_filtered (_("No threads match '%s'\n"), arg); 1365 } 1366 1367 /* Print notices when new threads are attached and detached. */ 1368 int print_thread_events = 1; 1369 static void 1370 show_print_thread_events (struct ui_file *file, int from_tty, 1371 struct cmd_list_element *c, const char *value) 1372 { 1373 fprintf_filtered (file, 1374 _("Printing of thread events is %s.\n"), 1375 value); 1376 } 1377 1378 static int 1379 do_captured_thread_select (struct ui_out *uiout, void *tidstr) 1380 { 1381 int num; 1382 struct thread_info *tp; 1383 1384 num = value_as_long (parse_and_eval (tidstr)); 1385 1386 tp = find_thread_id (num); 1387 1388 if (!tp) 1389 error (_("Thread ID %d not known."), num); 1390 1391 if (!thread_alive (tp)) 1392 error (_("Thread ID %d has terminated."), num); 1393 1394 switch_to_thread (tp->ptid); 1395 1396 annotate_thread_changed (); 1397 1398 ui_out_text (uiout, "[Switching to thread "); 1399 ui_out_field_int (uiout, "new-thread-id", pid_to_thread_id (inferior_ptid)); 1400 ui_out_text (uiout, " ("); 1401 ui_out_text (uiout, target_pid_to_str (inferior_ptid)); 1402 ui_out_text (uiout, ")]"); 1403 1404 /* Note that we can't reach this with an exited thread, due to the 1405 thread_alive check above. */ 1406 if (tp->state == THREAD_RUNNING) 1407 ui_out_text (uiout, "(running)\n"); 1408 else 1409 { 1410 ui_out_text (uiout, "\n"); 1411 print_stack_frame (get_selected_frame (NULL), 1, SRC_AND_LOC); 1412 } 1413 1414 /* Since the current thread may have changed, see if there is any 1415 exited thread we can now delete. */ 1416 prune_threads (); 1417 1418 return GDB_RC_OK; 1419 } 1420 1421 enum gdb_rc 1422 gdb_thread_select (struct ui_out *uiout, char *tidstr, char **error_message) 1423 { 1424 if (catch_exceptions_with_msg (uiout, do_captured_thread_select, tidstr, 1425 error_message, RETURN_MASK_ALL) < 0) 1426 return GDB_RC_FAIL; 1427 return GDB_RC_OK; 1428 } 1429 1430 void 1431 update_thread_list (void) 1432 { 1433 prune_threads (); 1434 target_find_new_threads (); 1435 } 1436 1437 /* Return a new value for the selected thread's id. Return a value of 0 if 1438 no thread is selected, or no threads exist. */ 1439 1440 static struct value * 1441 thread_id_make_value (struct gdbarch *gdbarch, struct internalvar *var, 1442 void *ignore) 1443 { 1444 struct thread_info *tp = find_thread_ptid (inferior_ptid); 1445 1446 return value_from_longest (builtin_type (gdbarch)->builtin_int, 1447 (tp ? tp->num : 0)); 1448 } 1449 1450 /* Commands with a prefix of `thread'. */ 1451 struct cmd_list_element *thread_cmd_list = NULL; 1452 1453 /* Implementation of `thread' variable. */ 1454 1455 static const struct internalvar_funcs thread_funcs = 1456 { 1457 thread_id_make_value, 1458 NULL, 1459 NULL 1460 }; 1461 1462 void 1463 _initialize_thread (void) 1464 { 1465 static struct cmd_list_element *thread_apply_list = NULL; 1466 1467 add_info ("threads", info_threads_command, 1468 _("Display currently known threads.\n\ 1469 Usage: info threads [ID]...\n\ 1470 Optional arguments are thread IDs with spaces between.\n\ 1471 If no arguments, all threads are displayed.")); 1472 1473 add_prefix_cmd ("thread", class_run, thread_command, _("\ 1474 Use this command to switch between threads.\n\ 1475 The new thread ID must be currently known."), 1476 &thread_cmd_list, "thread ", 1, &cmdlist); 1477 1478 add_prefix_cmd ("apply", class_run, thread_apply_command, 1479 _("Apply a command to a list of threads."), 1480 &thread_apply_list, "thread apply ", 1, &thread_cmd_list); 1481 1482 add_cmd ("all", class_run, thread_apply_all_command, 1483 _("Apply a command to all threads."), &thread_apply_list); 1484 1485 add_cmd ("name", class_run, thread_name_command, 1486 _("Set the current thread's name.\n\ 1487 Usage: thread name [NAME]\n\ 1488 If NAME is not given, then any existing name is removed."), &thread_cmd_list); 1489 1490 add_cmd ("find", class_run, thread_find_command, _("\ 1491 Find threads that match a regular expression.\n\ 1492 Usage: thread find REGEXP\n\ 1493 Will display thread ids whose name, target ID, or extra info matches REGEXP."), 1494 &thread_cmd_list); 1495 1496 if (!xdb_commands) 1497 add_com_alias ("t", "thread", class_run, 1); 1498 1499 add_setshow_boolean_cmd ("thread-events", no_class, 1500 &print_thread_events, _("\ 1501 Set printing of thread events (such as thread start and exit)."), _("\ 1502 Show printing of thread events (such as thread start and exit)."), NULL, 1503 NULL, 1504 show_print_thread_events, 1505 &setprintlist, &showprintlist); 1506 1507 create_internalvar_type_lazy ("_thread", &thread_funcs, NULL); 1508 } 1509