1/* Multi-process/thread control for GDB, the GNU debugger. 2 3 Copyright 1986, 1987, 1988, 1993, 1994, 1995, 1996, 1997, 1998, 4 1999, 2000, 2001, 2002, 2003 Free Software 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 2 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, write to the Free Software 22 Foundation, Inc., 59 Temple Place - Suite 330, 23 Boston, MA 02111-1307, USA. */ 24 25#include "defs.h" 26#include "symtab.h" 27#include "frame.h" 28#include "inferior.h" 29#include "environ.h" 30#include "value.h" 31#include "target.h" 32#include "gdbthread.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 44/*#include "lynxos-core.h" */ 45 46/* Definition of struct thread_info exported to gdbthread.h */ 47 48/* Prototypes for exported functions. */ 49 50void _initialize_thread (void); 51 52/* Prototypes for local functions. */ 53 54static struct thread_info *thread_list = NULL; 55static int highest_thread_num; 56 57static struct thread_info *find_thread_id (int num); 58 59static void thread_command (char *tidstr, int from_tty); 60static void thread_apply_all_command (char *, int); 61static int thread_alive (struct thread_info *); 62static void info_threads_command (char *, int); 63static void thread_apply_command (char *, int); 64static void restore_current_thread (ptid_t); 65static void switch_to_thread (ptid_t ptid); 66static void prune_threads (void); 67 68void 69delete_step_resume_breakpoint (void *arg) 70{ 71 struct breakpoint **breakpointp = (struct breakpoint **) arg; 72 struct thread_info *tp; 73 74 if (*breakpointp != NULL) 75 { 76 delete_breakpoint (*breakpointp); 77 for (tp = thread_list; tp; tp = tp->next) 78 if (tp->step_resume_breakpoint == *breakpointp) 79 tp->step_resume_breakpoint = NULL; 80 81 *breakpointp = NULL; 82 } 83} 84 85static void 86free_thread (struct thread_info *tp) 87{ 88 /* NOTE: this will take care of any left-over step_resume breakpoints, 89 but not any user-specified thread-specific breakpoints. */ 90 if (tp->step_resume_breakpoint) 91 delete_breakpoint (tp->step_resume_breakpoint); 92 93 /* FIXME: do I ever need to call the back-end to give it a 94 chance at this private data before deleting the thread? */ 95 if (tp->private) 96 xfree (tp->private); 97 98 xfree (tp); 99} 100 101void 102init_thread_list (void) 103{ 104 struct thread_info *tp, *tpnext; 105 106 highest_thread_num = 0; 107 if (!thread_list) 108 return; 109 110 for (tp = thread_list; tp; tp = tpnext) 111 { 112 tpnext = tp->next; 113 free_thread (tp); 114 } 115 116 thread_list = NULL; 117} 118 119/* add_thread now returns a pointer to the new thread_info, 120 so that back_ends can initialize their private data. */ 121 122struct thread_info * 123add_thread (ptid_t ptid) 124{ 125 struct thread_info *tp; 126 127 tp = (struct thread_info *) xmalloc (sizeof (*tp)); 128 memset (tp, 0, sizeof (*tp)); 129 tp->ptid = ptid; 130 tp->num = ++highest_thread_num; 131 tp->next = thread_list; 132 thread_list = tp; 133 return tp; 134} 135 136void 137delete_thread (ptid_t ptid) 138{ 139 struct thread_info *tp, *tpprev; 140 141 tpprev = NULL; 142 143 for (tp = thread_list; tp; tpprev = tp, tp = tp->next) 144 if (ptid_equal (tp->ptid, ptid)) 145 break; 146 147 if (!tp) 148 return; 149 150 if (tpprev) 151 tpprev->next = tp->next; 152 else 153 thread_list = tp->next; 154 155 free_thread (tp); 156} 157 158static struct thread_info * 159find_thread_id (int num) 160{ 161 struct thread_info *tp; 162 163 for (tp = thread_list; tp; tp = tp->next) 164 if (tp->num == num) 165 return tp; 166 167 return NULL; 168} 169 170/* Find a thread_info by matching PTID. */ 171struct thread_info * 172find_thread_pid (ptid_t ptid) 173{ 174 struct thread_info *tp; 175 176 for (tp = thread_list; tp; tp = tp->next) 177 if (ptid_equal (tp->ptid, ptid)) 178 return tp; 179 180 return NULL; 181} 182 183/* 184 * Thread iterator function. 185 * 186 * Calls a callback function once for each thread, so long as 187 * the callback function returns false. If the callback function 188 * returns true, the iteration will end and the current thread 189 * will be returned. This can be useful for implementing a 190 * search for a thread with arbitrary attributes, or for applying 191 * some operation to every thread. 192 * 193 * FIXME: some of the existing functionality, such as 194 * "Thread apply all", might be rewritten using this functionality. 195 */ 196 197struct thread_info * 198iterate_over_threads (int (*callback) (struct thread_info *, void *), 199 void *data) 200{ 201 struct thread_info *tp; 202 203 for (tp = thread_list; tp; tp = tp->next) 204 if ((*callback) (tp, data)) 205 return tp; 206 207 return NULL; 208} 209 210int 211valid_thread_id (int num) 212{ 213 struct thread_info *tp; 214 215 for (tp = thread_list; tp; tp = tp->next) 216 if (tp->num == num) 217 return 1; 218 219 return 0; 220} 221 222int 223pid_to_thread_id (ptid_t ptid) 224{ 225 struct thread_info *tp; 226 227 for (tp = thread_list; tp; tp = tp->next) 228 if (ptid_equal (tp->ptid, ptid)) 229 return tp->num; 230 231 return 0; 232} 233 234ptid_t 235thread_id_to_pid (int num) 236{ 237 struct thread_info *thread = find_thread_id (num); 238 if (thread) 239 return thread->ptid; 240 else 241 return pid_to_ptid (-1); 242} 243 244int 245in_thread_list (ptid_t ptid) 246{ 247 struct thread_info *tp; 248 249 for (tp = thread_list; tp; tp = tp->next) 250 if (ptid_equal (tp->ptid, ptid)) 251 return 1; 252 253 return 0; /* Never heard of 'im */ 254} 255 256/* Print a list of thread ids currently known, and the total number of 257 threads. To be used from within catch_errors. */ 258static int 259do_captured_list_thread_ids (struct ui_out *uiout, void *arg) 260{ 261 struct thread_info *tp; 262 int num = 0; 263 struct cleanup *cleanup_chain; 264 265 prune_threads (); 266 target_find_new_threads (); 267 268 cleanup_chain = make_cleanup_ui_out_tuple_begin_end (uiout, "thread-ids"); 269 270 for (tp = thread_list; tp; tp = tp->next) 271 { 272 num++; 273 ui_out_field_int (uiout, "thread-id", tp->num); 274 } 275 276 do_cleanups (cleanup_chain); 277 ui_out_field_int (uiout, "number-of-threads", num); 278 return GDB_RC_OK; 279} 280 281/* Official gdblib interface function to get a list of thread ids and 282 the total number. */ 283enum gdb_rc 284gdb_list_thread_ids (struct ui_out *uiout) 285{ 286 return catch_exceptions (uiout, do_captured_list_thread_ids, NULL, 287 NULL, RETURN_MASK_ALL); 288} 289 290/* Load infrun state for the thread PID. */ 291 292void 293load_infrun_state (ptid_t ptid, 294 CORE_ADDR *prev_pc, 295 int *trap_expected, 296 struct breakpoint **step_resume_breakpoint, 297 struct breakpoint **through_sigtramp_breakpoint, 298 CORE_ADDR *step_range_start, 299 CORE_ADDR *step_range_end, 300 struct frame_id *step_frame_id, 301 int *handling_longjmp, 302 int *another_trap, 303 int *stepping_through_solib_after_catch, 304 bpstat *stepping_through_solib_catchpoints, 305 int *stepping_through_sigtramp, 306 int *current_line, 307 struct symtab **current_symtab, CORE_ADDR *step_sp) 308{ 309 struct thread_info *tp; 310 311 /* If we can't find the thread, then we're debugging a single threaded 312 process. No need to do anything in that case. */ 313 tp = find_thread_id (pid_to_thread_id (ptid)); 314 if (tp == NULL) 315 return; 316 317 *prev_pc = tp->prev_pc; 318 *trap_expected = tp->trap_expected; 319 *step_resume_breakpoint = tp->step_resume_breakpoint; 320 *through_sigtramp_breakpoint = tp->through_sigtramp_breakpoint; 321 *step_range_start = tp->step_range_start; 322 *step_range_end = tp->step_range_end; 323 *step_frame_id = tp->step_frame_id; 324 *handling_longjmp = tp->handling_longjmp; 325 *another_trap = tp->another_trap; 326 *stepping_through_solib_after_catch = 327 tp->stepping_through_solib_after_catch; 328 *stepping_through_solib_catchpoints = 329 tp->stepping_through_solib_catchpoints; 330 *stepping_through_sigtramp = tp->stepping_through_sigtramp; 331 *current_line = tp->current_line; 332 *current_symtab = tp->current_symtab; 333 *step_sp = tp->step_sp; 334} 335 336/* Save infrun state for the thread PID. */ 337 338void 339save_infrun_state (ptid_t ptid, 340 CORE_ADDR prev_pc, 341 int trap_expected, 342 struct breakpoint *step_resume_breakpoint, 343 struct breakpoint *through_sigtramp_breakpoint, 344 CORE_ADDR step_range_start, 345 CORE_ADDR step_range_end, 346 const struct frame_id *step_frame_id, 347 int handling_longjmp, 348 int another_trap, 349 int stepping_through_solib_after_catch, 350 bpstat stepping_through_solib_catchpoints, 351 int stepping_through_sigtramp, 352 int current_line, 353 struct symtab *current_symtab, CORE_ADDR step_sp) 354{ 355 struct thread_info *tp; 356 357 /* If we can't find the thread, then we're debugging a single-threaded 358 process. Nothing to do in that case. */ 359 tp = find_thread_id (pid_to_thread_id (ptid)); 360 if (tp == NULL) 361 return; 362 363 tp->prev_pc = prev_pc; 364 tp->trap_expected = trap_expected; 365 tp->step_resume_breakpoint = step_resume_breakpoint; 366 tp->through_sigtramp_breakpoint = through_sigtramp_breakpoint; 367 tp->step_range_start = step_range_start; 368 tp->step_range_end = step_range_end; 369 tp->step_frame_id = (*step_frame_id); 370 tp->handling_longjmp = handling_longjmp; 371 tp->another_trap = another_trap; 372 tp->stepping_through_solib_after_catch = stepping_through_solib_after_catch; 373 tp->stepping_through_solib_catchpoints = stepping_through_solib_catchpoints; 374 tp->stepping_through_sigtramp = stepping_through_sigtramp; 375 tp->current_line = current_line; 376 tp->current_symtab = current_symtab; 377 tp->step_sp = step_sp; 378} 379 380/* Return true if TP is an active thread. */ 381static int 382thread_alive (struct thread_info *tp) 383{ 384 if (PIDGET (tp->ptid) == -1) 385 return 0; 386 if (!target_thread_alive (tp->ptid)) 387 { 388 tp->ptid = pid_to_ptid (-1); /* Mark it as dead */ 389 return 0; 390 } 391 return 1; 392} 393 394static void 395prune_threads (void) 396{ 397 struct thread_info *tp, *next; 398 399 for (tp = thread_list; tp; tp = next) 400 { 401 next = tp->next; 402 if (!thread_alive (tp)) 403 delete_thread (tp->ptid); 404 } 405} 406 407/* Print information about currently known threads 408 409 * Note: this has the drawback that it _really_ switches 410 * threads, which frees the frame cache. A no-side 411 * effects info-threads command would be nicer. 412 */ 413 414static void 415info_threads_command (char *arg, int from_tty) 416{ 417 struct thread_info *tp; 418 ptid_t current_ptid; 419 struct frame_info *cur_frame; 420 int saved_frame_level = frame_relative_level (get_selected_frame ()); 421 int counter; 422 char *extra_info; 423 424 /* Check that there really is a frame. This happens when a simulator 425 is connected but not loaded or running, for instance. */ 426 if (legacy_frame_p (current_gdbarch) && saved_frame_level < 0) 427 error ("No frame."); 428 429 prune_threads (); 430 target_find_new_threads (); 431 current_ptid = inferior_ptid; 432 for (tp = thread_list; tp; tp = tp->next) 433 { 434 if (ptid_equal (tp->ptid, current_ptid)) 435 printf_filtered ("* "); 436 else 437 printf_filtered (" "); 438 439#ifdef HPUXHPPA 440 printf_filtered ("%d %s", tp->num, target_tid_to_str (tp->ptid)); 441#else 442 printf_filtered ("%d %s", tp->num, target_pid_to_str (tp->ptid)); 443#endif 444 445 extra_info = target_extra_thread_info (tp); 446 if (extra_info) 447 printf_filtered (" (%s)", extra_info); 448 puts_filtered (" "); 449 450 switch_to_thread (tp->ptid); 451 print_stack_frame (get_selected_frame (), -1, 0); 452 } 453 454 switch_to_thread (current_ptid); 455 456 /* Code below copied from "up_silently_base" in "stack.c". 457 * It restores the frame set by the user before the "info threads" 458 * command. We have finished the info-threads display by switching 459 * back to the current thread. That switch has put us at the top 460 * of the stack (leaf frame). 461 */ 462 counter = saved_frame_level; 463 cur_frame = find_relative_frame (get_selected_frame (), &counter); 464 if (counter != 0) 465 { 466 /* Ooops, can't restore, tell user where we are. */ 467 warning ("Couldn't restore frame in current thread, at frame 0"); 468 print_stack_frame (get_selected_frame (), -1, 0); 469 } 470 else 471 { 472 select_frame (cur_frame); 473 } 474 475 /* re-show current frame. */ 476 show_stack_frame (cur_frame); 477} 478 479/* Switch from one thread to another. */ 480 481static void 482switch_to_thread (ptid_t ptid) 483{ 484 if (ptid_equal (ptid, inferior_ptid)) 485 return; 486 487 inferior_ptid = ptid; 488 flush_cached_frames (); 489 registers_changed (); 490 stop_pc = read_pc (); 491 select_frame (get_current_frame ()); 492} 493 494static void 495restore_current_thread (ptid_t ptid) 496{ 497 if (!ptid_equal (ptid, inferior_ptid)) 498 { 499 switch_to_thread (ptid); 500 print_stack_frame (get_current_frame (), 0, -1); 501 } 502} 503 504struct current_thread_cleanup 505{ 506 ptid_t inferior_ptid; 507}; 508 509static void 510do_restore_current_thread_cleanup (void *arg) 511{ 512 struct current_thread_cleanup *old = arg; 513 restore_current_thread (old->inferior_ptid); 514 xfree (old); 515} 516 517static struct cleanup * 518make_cleanup_restore_current_thread (ptid_t inferior_ptid) 519{ 520 struct current_thread_cleanup *old 521 = xmalloc (sizeof (struct current_thread_cleanup)); 522 old->inferior_ptid = inferior_ptid; 523 return make_cleanup (do_restore_current_thread_cleanup, old); 524} 525 526/* Apply a GDB command to a list of threads. List syntax is a whitespace 527 seperated list of numbers, or ranges, or the keyword `all'. Ranges consist 528 of two numbers seperated by a hyphen. Examples: 529 530 thread apply 1 2 7 4 backtrace Apply backtrace cmd to threads 1,2,7,4 531 thread apply 2-7 9 p foo(1) Apply p foo(1) cmd to threads 2->7 & 9 532 thread apply all p x/i $pc Apply x/i $pc cmd to all threads 533 */ 534 535static void 536thread_apply_all_command (char *cmd, int from_tty) 537{ 538 struct thread_info *tp; 539 struct cleanup *old_chain; 540 struct cleanup *saved_cmd_cleanup_chain; 541 char *saved_cmd; 542 543 if (cmd == NULL || *cmd == '\000') 544 error ("Please specify a command following the thread ID list"); 545 546 old_chain = make_cleanup_restore_current_thread (inferior_ptid); 547 548 /* It is safe to update the thread list now, before 549 traversing it for "thread apply all". MVS */ 550 target_find_new_threads (); 551 552 /* Save a copy of the command in case it is clobbered by 553 execute_command */ 554 saved_cmd = xstrdup (cmd); 555 saved_cmd_cleanup_chain = make_cleanup (xfree, (void *) saved_cmd); 556 for (tp = thread_list; tp; tp = tp->next) 557 if (thread_alive (tp)) 558 { 559 switch_to_thread (tp->ptid); 560#ifdef HPUXHPPA 561 printf_filtered ("\nThread %d (%s):\n", 562 tp->num, target_tid_to_str (inferior_ptid)); 563#else 564 printf_filtered ("\nThread %d (%s):\n", tp->num, 565 target_pid_to_str (inferior_ptid)); 566#endif 567 execute_command (cmd, from_tty); 568 strcpy (cmd, saved_cmd); /* Restore exact command used previously */ 569 } 570 571 do_cleanups (saved_cmd_cleanup_chain); 572 do_cleanups (old_chain); 573} 574 575static void 576thread_apply_command (char *tidlist, int from_tty) 577{ 578 char *cmd; 579 char *p; 580 struct cleanup *old_chain; 581 struct cleanup *saved_cmd_cleanup_chain; 582 char *saved_cmd; 583 584 if (tidlist == NULL || *tidlist == '\000') 585 error ("Please specify a thread ID list"); 586 587 for (cmd = tidlist; *cmd != '\000' && !isalpha (*cmd); cmd++); 588 589 if (*cmd == '\000') 590 error ("Please specify a command following the thread ID list"); 591 592 old_chain = make_cleanup_restore_current_thread (inferior_ptid); 593 594 /* Save a copy of the command in case it is clobbered by 595 execute_command */ 596 saved_cmd = xstrdup (cmd); 597 saved_cmd_cleanup_chain = make_cleanup (xfree, (void *) saved_cmd); 598 while (tidlist < cmd) 599 { 600 struct thread_info *tp; 601 int start, end; 602 603 start = strtol (tidlist, &p, 10); 604 if (p == tidlist) 605 error ("Error parsing %s", tidlist); 606 tidlist = p; 607 608 while (*tidlist == ' ' || *tidlist == '\t') 609 tidlist++; 610 611 if (*tidlist == '-') /* Got a range of IDs? */ 612 { 613 tidlist++; /* Skip the - */ 614 end = strtol (tidlist, &p, 10); 615 if (p == tidlist) 616 error ("Error parsing %s", tidlist); 617 tidlist = p; 618 619 while (*tidlist == ' ' || *tidlist == '\t') 620 tidlist++; 621 } 622 else 623 end = start; 624 625 for (; start <= end; start++) 626 { 627 tp = find_thread_id (start); 628 629 if (!tp) 630 warning ("Unknown thread %d.", start); 631 else if (!thread_alive (tp)) 632 warning ("Thread %d has terminated.", start); 633 else 634 { 635 switch_to_thread (tp->ptid); 636#ifdef HPUXHPPA 637 printf_filtered ("\nThread %d (%s):\n", tp->num, 638 target_tid_to_str (inferior_ptid)); 639#else 640 printf_filtered ("\nThread %d (%s):\n", tp->num, 641 target_pid_to_str (inferior_ptid)); 642#endif 643 execute_command (cmd, from_tty); 644 strcpy (cmd, saved_cmd); /* Restore exact command used previously */ 645 } 646 } 647 } 648 649 do_cleanups (saved_cmd_cleanup_chain); 650 do_cleanups (old_chain); 651} 652 653/* Switch to the specified thread. Will dispatch off to thread_apply_command 654 if prefix of arg is `apply'. */ 655 656static void 657thread_command (char *tidstr, int from_tty) 658{ 659 if (!tidstr) 660 { 661 /* Don't generate an error, just say which thread is current. */ 662 if (target_has_stack) 663 printf_filtered ("[Current thread is %d (%s)]\n", 664 pid_to_thread_id (inferior_ptid), 665#if defined(HPUXHPPA) 666 target_tid_to_str (inferior_ptid) 667#else 668 target_pid_to_str (inferior_ptid) 669#endif 670 ); 671 else 672 error ("No stack."); 673 return; 674 } 675 676 gdb_thread_select (uiout, tidstr); 677} 678 679static int 680do_captured_thread_select (struct ui_out *uiout, void *tidstr) 681{ 682 int num; 683 struct thread_info *tp; 684 685 num = value_as_long (parse_and_eval (tidstr)); 686 687 tp = find_thread_id (num); 688 689 if (!tp) 690 error ("Thread ID %d not known.", num); 691 692 if (!thread_alive (tp)) 693 error ("Thread ID %d has terminated.\n", num); 694 695 switch_to_thread (tp->ptid); 696 697 ui_out_text (uiout, "[Switching to thread "); 698 ui_out_field_int (uiout, "new-thread-id", pid_to_thread_id (inferior_ptid)); 699 ui_out_text (uiout, " ("); 700#if defined(HPUXHPPA) 701 ui_out_text (uiout, target_tid_to_str (inferior_ptid)); 702#else 703 ui_out_text (uiout, target_pid_to_str (inferior_ptid)); 704#endif 705 ui_out_text (uiout, ")]"); 706 707 print_stack_frame (deprecated_selected_frame, 708 frame_relative_level (deprecated_selected_frame), 1); 709 return GDB_RC_OK; 710} 711 712enum gdb_rc 713gdb_thread_select (struct ui_out *uiout, char *tidstr) 714{ 715 return catch_exceptions (uiout, do_captured_thread_select, tidstr, 716 NULL, RETURN_MASK_ALL); 717} 718 719/* Commands with a prefix of `thread'. */ 720struct cmd_list_element *thread_cmd_list = NULL; 721 722void 723_initialize_thread (void) 724{ 725 static struct cmd_list_element *thread_apply_list = NULL; 726 727 add_info ("threads", info_threads_command, 728 "IDs of currently known threads."); 729 730 add_prefix_cmd ("thread", class_run, thread_command, 731 "Use this command to switch between threads.\n\ 732The new thread ID must be currently known.", &thread_cmd_list, "thread ", 1, &cmdlist); 733 734 add_prefix_cmd ("apply", class_run, thread_apply_command, 735 "Apply a command to a list of threads.", 736 &thread_apply_list, "apply ", 1, &thread_cmd_list); 737 738 add_cmd ("all", class_run, thread_apply_all_command, 739 "Apply a command to all threads.", &thread_apply_list); 740 741 if (!xdb_commands) 742 add_com_alias ("t", "thread", class_run, 1); 743} 744