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