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