1 /* Multi-process control for GDB, the GNU debugger.
3 Copyright (C) 2008, 2009, 2010, 2011 Free Software Foundation, Inc.
5 This file is part of GDB.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program. If not, see <http://www.gnu.org/licenses/>. */
26 #include "gdbthread.h"
29 #include "gdbthread.h"
33 #include "cli/cli-utils.h"
35 void _initialize_inferiors (void);
37 static void inferior_alloc_data (struct inferior *inf);
38 static void inferior_free_data (struct inferior *inf);
40 struct inferior *inferior_list = NULL;
41 static int highest_inferior_num;
43 /* Print notices on inferior events (attach, detach, etc.), set with
44 `set print inferior-events'. */
45 static int print_inferior_events = 0;
47 /* The Current Inferior. */
48 static struct inferior *current_inferior_ = NULL;
51 current_inferior (void)
53 return current_inferior_;
57 set_current_inferior (struct inferior *inf)
59 /* There's always an inferior. */
60 gdb_assert (inf != NULL);
62 current_inferior_ = inf;
65 /* A cleanups callback, helper for save_current_program_space
69 restore_inferior (void *arg)
71 struct inferior *saved_inferior = arg;
73 set_current_inferior (saved_inferior);
76 /* Save the current program space so that it may be restored by a later
77 call to do_cleanups. Returns the struct cleanup pointer needed for
78 later doing the cleanup. */
81 save_current_inferior (void)
83 struct cleanup *old_chain = make_cleanup (restore_inferior,
90 free_inferior (struct inferior *inf)
92 discard_all_inferior_continuations (inf);
93 inferior_free_data (inf);
95 xfree (inf->terminal);
96 free_environ (inf->environment);
102 init_inferior_list (void)
104 struct inferior *inf, *infnext;
106 highest_inferior_num = 0;
110 for (inf = inferior_list; inf; inf = infnext)
116 inferior_list = NULL;
120 add_inferior_silent (int pid)
122 struct inferior *inf;
124 inf = xmalloc (sizeof (*inf));
125 memset (inf, 0, sizeof (*inf));
128 inf->control.stop_soon = NO_STOP_QUIETLY;
130 inf->num = ++highest_inferior_num;
131 inf->next = inferior_list;
134 inf->environment = make_environ ();
135 init_environ (inf->environment);
137 inferior_alloc_data (inf);
139 observer_notify_inferior_added (inf);
141 if (kernel_debugger || (pid != 0))
142 inferior_appeared (inf, pid);
148 add_inferior (int pid)
150 struct inferior *inf = add_inferior_silent (pid);
152 if (print_inferior_events)
153 printf_unfiltered (_("[New inferior %d]\n"), pid);
158 struct delete_thread_of_inferior_arg
165 delete_thread_of_inferior (struct thread_info *tp, void *data)
167 struct delete_thread_of_inferior_arg *arg = data;
169 if (ptid_get_pid (tp->ptid) == arg->pid)
172 delete_thread_silent (tp->ptid);
174 delete_thread (tp->ptid);
181 delete_threads_of_inferior (int pid)
183 struct inferior *inf;
184 struct delete_thread_of_inferior_arg arg;
186 for (inf = inferior_list; inf; inf = inf->next)
196 iterate_over_threads (delete_thread_of_inferior, &arg);
199 /* If SILENT then be quiet -- don't announce a inferior death, or the
200 exit of its threads. */
203 delete_inferior_1 (struct inferior *todel, int silent)
205 struct inferior *inf, *infprev;
206 struct delete_thread_of_inferior_arg arg;
210 for (inf = inferior_list; inf; infprev = inf, inf = inf->next)
220 iterate_over_threads (delete_thread_of_inferior, &arg);
223 infprev->next = inf->next;
225 inferior_list = inf->next;
227 observer_notify_inferior_removed (inf);
233 delete_inferior (int pid)
235 struct inferior *inf = find_inferior_pid (pid);
237 delete_inferior_1 (inf, 0);
239 if (print_inferior_events)
240 printf_unfiltered (_("[Inferior %d exited]\n"), pid);
244 delete_inferior_silent (int pid)
246 struct inferior *inf = find_inferior_pid (pid);
248 delete_inferior_1 (inf, 1);
252 /* If SILENT then be quiet -- don't announce a inferior exit, or the
253 exit of its threads. */
256 exit_inferior_1 (struct inferior *inftoex, int silent)
258 struct inferior *inf;
259 struct delete_thread_of_inferior_arg arg;
261 for (inf = inferior_list; inf; inf = inf->next)
271 iterate_over_threads (delete_thread_of_inferior, &arg);
273 /* Notify the observers before removing the inferior from the list,
274 so that the observers have a chance to look it up. */
275 observer_notify_inferior_exit (inf);
278 if (inf->vfork_parent != NULL)
280 inf->vfork_parent->vfork_child = NULL;
281 inf->vfork_parent = NULL;
284 inf->has_exit_code = 0;
289 exit_inferior (int pid)
291 struct inferior *inf = find_inferior_pid (pid);
293 exit_inferior_1 (inf, 0);
295 if (print_inferior_events)
296 printf_unfiltered (_("[Inferior %d exited]\n"), pid);
300 exit_inferior_silent (int pid)
302 struct inferior *inf = find_inferior_pid (pid);
304 exit_inferior_1 (inf, 1);
308 exit_inferior_num_silent (int num)
310 struct inferior *inf = find_inferior_id (num);
312 exit_inferior_1 (inf, 1);
316 detach_inferior (int pid)
318 struct inferior *inf = find_inferior_pid (pid);
320 exit_inferior_1 (inf, 1);
322 if (print_inferior_events)
323 printf_unfiltered (_("[Inferior %d detached]\n"), pid);
327 inferior_appeared (struct inferior *inf, int pid)
331 observer_notify_inferior_appeared (inf);
335 discard_all_inferiors (void)
337 struct inferior *inf;
339 for (inf = inferior_list; inf; inf = inf->next)
341 if (kernel_debugger || (inf->pid != 0))
342 exit_inferior_silent (inf->pid);
347 find_inferior_id (int num)
349 struct inferior *inf;
351 for (inf = inferior_list; inf; inf = inf->next)
359 find_inferior_pid (int pid)
361 struct inferior *inf;
363 /* Looking for inferior pid == 0 is always wrong, and indicative of
364 a bug somewhere else. There may be more than one with pid == 0,
366 gdb_assert (kernel_debugger || (pid != 0));
368 for (inf = inferior_list; inf; inf = inf->next)
375 /* Find an inferior bound to PSPACE. */
378 find_inferior_for_program_space (struct program_space *pspace)
380 struct inferior *inf;
382 for (inf = inferior_list; inf != NULL; inf = inf->next)
384 if (inf->pspace == pspace)
392 iterate_over_inferiors (int (*callback) (struct inferior *, void *),
395 struct inferior *inf, *infnext;
397 for (inf = inferior_list; inf; inf = infnext)
400 if ((*callback) (inf, data))
408 valid_gdb_inferior_id (int num)
410 struct inferior *inf;
412 for (inf = inferior_list; inf; inf = inf->next)
420 pid_to_gdb_inferior_id (int pid)
422 struct inferior *inf;
424 for (inf = inferior_list; inf; inf = inf->next)
432 gdb_inferior_id_to_pid (int num)
434 struct inferior *inferior = find_inferior_id (num);
436 return inferior->pid;
442 in_inferior_list (int pid)
444 struct inferior *inf;
446 for (inf = inferior_list; inf; inf = inf->next)
454 have_inferiors (void)
456 struct inferior *inf;
458 for (inf = inferior_list; inf; inf = inf->next)
459 if (kernel_debugger || (inf->pid != 0))
466 have_live_inferiors (void)
468 struct inferior *inf;
470 for (inf = inferior_list; inf; inf = inf->next)
473 struct thread_info *tp;
475 tp = any_thread_of_process (inf->pid);
476 if (tp && target_has_execution_1 (tp->ptid))
483 /* Prune away automatically added program spaces that aren't required
487 prune_inferiors (void)
489 struct inferior *ss, **ss_link;
490 struct inferior *current = current_inferior ();
493 ss_link = &inferior_list;
498 || (kernel_debugger || (ss->pid != 0)))
506 delete_inferior_1 (ss, 1);
510 prune_program_spaces ();
513 /* Simply returns the count of inferiors. */
516 number_of_inferiors (void)
518 struct inferior *inf;
521 for (inf = inferior_list; inf != NULL; inf = inf->next)
527 /* Prints the list of inferiors and their details on UIOUT. This is a
528 version of 'info_inferior_command' suitable for use from MI.
530 If REQUESTED_INFERIORS is not NULL, it's a list of GDB ids of the
531 inferiors that should be printed. Otherwise, all inferiors are
535 print_inferior (struct ui_out *uiout, char *requested_inferiors)
537 struct inferior *inf;
538 struct cleanup *old_chain;
541 /* Compute number of inferiors we will print. */
542 for (inf = inferior_list; inf; inf = inf->next)
544 if (!number_is_in_list (requested_inferiors, inf->num))
552 ui_out_message (uiout, 0, "No inferiors.\n");
556 old_chain = make_cleanup_ui_out_table_begin_end (uiout, 4, inf_count,
558 ui_out_table_header (uiout, 1, ui_left, "current", "");
559 ui_out_table_header (uiout, 4, ui_left, "number", "Num");
560 ui_out_table_header (uiout, 17, ui_left, "target-id", "Description");
561 ui_out_table_header (uiout, 17, ui_left, "exec", "Executable");
563 ui_out_table_body (uiout);
564 for (inf = inferior_list; inf; inf = inf->next)
566 struct cleanup *chain2;
568 if (!number_is_in_list (requested_inferiors, inf->num))
571 chain2 = make_cleanup_ui_out_tuple_begin_end (uiout, NULL);
573 if (inf == current_inferior ())
574 ui_out_field_string (uiout, "current", "*");
576 ui_out_field_skip (uiout, "current");
578 ui_out_field_int (uiout, "number", inf->num);
580 if (kernel_debugger || (inf->pid != 0))
581 ui_out_field_string (uiout, "target-id",
582 target_pid_to_str (pid_to_ptid (inf->pid)));
584 ui_out_field_string (uiout, "target-id", "<null>");
586 if (inf->pspace->ebfd)
587 ui_out_field_string (uiout, "exec",
588 bfd_get_filename (inf->pspace->ebfd));
590 ui_out_field_skip (uiout, "exec");
592 /* Print extra info that isn't really fit to always present in
593 tabular form. Currently we print the vfork parent/child
594 relationships, if any. */
595 if (inf->vfork_parent)
597 ui_out_text (uiout, _("\n\tis vfork child of inferior "));
598 ui_out_field_int (uiout, "vfork-parent", inf->vfork_parent->num);
600 if (inf->vfork_child)
602 ui_out_text (uiout, _("\n\tis vfork parent of inferior "));
603 ui_out_field_int (uiout, "vfork-child", inf->vfork_child->num);
606 ui_out_text (uiout, "\n");
607 do_cleanups (chain2);
610 do_cleanups (old_chain);
614 detach_inferior_command (char *args, int from_tty)
617 struct thread_info *tp;
618 struct get_number_or_range_state state;
621 error (_("Requires argument (inferior id(s) to detach)"));
623 init_number_or_range (&state, args);
624 while (!state.finished)
626 num = get_number_or_range (&state);
628 if (!valid_gdb_inferior_id (num))
630 warning (_("Inferior ID %d not known."), num);
634 pid = gdb_inferior_id_to_pid (num);
636 tp = any_thread_of_process (pid);
639 warning (_("Inferior ID %d has no threads."), num);
643 switch_to_thread (tp->ptid);
645 detach_command (NULL, from_tty);
650 kill_inferior_command (char *args, int from_tty)
653 struct thread_info *tp;
654 struct get_number_or_range_state state;
657 error (_("Requires argument (inferior id(s) to kill)"));
659 init_number_or_range (&state, args);
660 while (!state.finished)
662 num = get_number_or_range (&state);
664 if (!valid_gdb_inferior_id (num))
666 warning (_("Inferior ID %d not known."), num);
670 pid = gdb_inferior_id_to_pid (num);
672 tp = any_thread_of_process (pid);
675 warning (_("Inferior ID %d has no threads."), num);
679 switch_to_thread (tp->ptid);
684 bfd_cache_close_all ();
688 inferior_command (char *args, int from_tty)
690 struct inferior *inf;
693 num = parse_and_eval_long (args);
695 inf = find_inferior_id (num);
697 error (_("Inferior ID %d not known."), num);
699 printf_filtered (_("[Switching to inferior %d [%s] (%s)]\n"),
701 target_pid_to_str (pid_to_ptid (inf->pid)),
703 ? bfd_get_filename (inf->pspace->ebfd)
708 if (inf->pid != ptid_get_pid (inferior_ptid))
710 struct thread_info *tp;
712 tp = any_thread_of_process (inf->pid);
714 error (_("Inferior has no threads."));
716 switch_to_thread (tp->ptid);
719 printf_filtered (_("[Switching to thread %d (%s)] "),
720 pid_to_thread_id (inferior_ptid),
721 target_pid_to_str (inferior_ptid));
725 struct inferior *inf;
727 inf = find_inferior_id (num);
728 set_current_inferior (inf);
729 switch_to_thread (null_ptid);
730 set_current_program_space (inf->pspace);
733 if (inf->pid != 0 && is_running (inferior_ptid))
734 ui_out_text (uiout, "(running)\n");
735 else if (inf->pid != 0)
737 ui_out_text (uiout, "\n");
738 print_stack_frame (get_selected_frame (NULL), 1, SRC_AND_LOC);
742 /* Print information about currently known inferiors. */
745 info_inferiors_command (char *args, int from_tty)
747 print_inferior (uiout, args);
750 /* remove-inferior ID */
753 remove_inferior_command (char *args, int from_tty)
756 struct inferior *inf;
757 struct get_number_or_range_state state;
759 if (args == NULL || *args == '\0')
760 error (_("Requires an argument (inferior id(s) to remove)"));
762 init_number_or_range (&state, args);
763 while (!state.finished)
765 num = get_number_or_range (&state);
766 inf = find_inferior_id (num);
770 warning (_("Inferior ID %d not known."), num);
774 if (inf == current_inferior ())
776 warning (_("Can not remove current symbol inferior %d."), num);
782 warning (_("Can not remove active inferior %d."), num);
786 delete_inferior_1 (inf, 1);
791 add_inferior_with_spaces (void)
793 struct address_space *aspace;
794 struct program_space *pspace;
795 struct inferior *inf;
797 /* If all inferiors share an address space on this system, this
798 doesn't really return a new address space; otherwise, it
800 aspace = maybe_new_address_space ();
801 pspace = add_program_space (aspace);
802 inf = add_inferior (0);
803 inf->pspace = pspace;
804 inf->aspace = pspace->aspace;
809 /* add-inferior [-copies N] [-exec FILENAME] */
812 add_inferior_command (char *args, int from_tty)
817 struct cleanup *old_chain = make_cleanup (null_cleanup, NULL);
821 argv = gdb_buildargv (args);
822 make_cleanup_freeargv (argv);
824 for (; *argv != NULL; argv++)
828 if (strcmp (*argv, "-copies") == 0)
832 error (_("No argument to -copies"));
833 copies = parse_and_eval_long (*argv);
835 else if (strcmp (*argv, "-exec") == 0)
839 error (_("No argument to -exec"));
844 error (_("Invalid argument"));
848 save_current_space_and_thread ();
850 for (i = 0; i < copies; ++i)
852 struct inferior *inf = add_inferior_with_spaces ();
854 printf_filtered (_("Added inferior %d\n"), inf->num);
858 /* Switch over temporarily, while reading executable and
860 set_current_program_space (inf->pspace);
861 set_current_inferior (inf);
862 switch_to_thread (null_ptid);
864 exec_file_attach (exec, from_tty);
865 symbol_file_add_main (exec, from_tty);
869 do_cleanups (old_chain);
872 /* clone-inferior [-copies N] [ID] */
875 clone_inferior_command (char *args, int from_tty)
879 struct inferior *orginf = NULL;
880 struct cleanup *old_chain = make_cleanup (null_cleanup, NULL);
884 argv = gdb_buildargv (args);
885 make_cleanup_freeargv (argv);
887 for (; *argv != NULL; argv++)
891 if (strcmp (*argv, "-copies") == 0)
895 error (_("No argument to -copies"));
896 copies = parse_and_eval_long (*argv);
899 error (_("Invalid copies number"));
908 /* The first non-option (-) argument specified the
910 num = parse_and_eval_long (*argv);
911 orginf = find_inferior_id (num);
914 error (_("Inferior ID %d not known."), num);
918 error (_("Invalid argument"));
923 /* If no inferior id was specified, then the user wants to clone the
926 orginf = current_inferior ();
928 save_current_space_and_thread ();
930 for (i = 0; i < copies; ++i)
932 struct address_space *aspace;
933 struct program_space *pspace;
934 struct inferior *inf;
936 /* If all inferiors share an address space on this system, this
937 doesn't really return a new address space; otherwise, it
939 aspace = maybe_new_address_space ();
940 pspace = add_program_space (aspace);
941 inf = add_inferior (0);
942 inf->pspace = pspace;
943 inf->aspace = pspace->aspace;
945 printf_filtered (_("Added inferior %d.\n"), inf->num);
947 set_current_inferior (inf);
948 switch_to_thread (null_ptid);
949 clone_program_space (pspace, orginf->pspace);
952 do_cleanups (old_chain);
955 /* Print notices when new inferiors are created and die. */
957 show_print_inferior_events (struct ui_file *file, int from_tty,
958 struct cmd_list_element *c, const char *value)
960 fprintf_filtered (file, _("Printing of inferior events is %s.\n"), value);
965 /* Keep a registry of per-inferior data-pointers required by other GDB
971 void (*cleanup) (struct inferior *, void *);
974 struct inferior_data_registration
976 struct inferior_data *data;
977 struct inferior_data_registration *next;
980 struct inferior_data_registry
982 struct inferior_data_registration *registrations;
983 unsigned num_registrations;
986 static struct inferior_data_registry inferior_data_registry
989 const struct inferior_data *
990 register_inferior_data_with_cleanup
991 (void (*cleanup) (struct inferior *, void *))
993 struct inferior_data_registration **curr;
995 /* Append new registration. */
996 for (curr = &inferior_data_registry.registrations;
997 *curr != NULL; curr = &(*curr)->next);
999 *curr = XMALLOC (struct inferior_data_registration);
1000 (*curr)->next = NULL;
1001 (*curr)->data = XMALLOC (struct inferior_data);
1002 (*curr)->data->index = inferior_data_registry.num_registrations++;
1003 (*curr)->data->cleanup = cleanup;
1005 return (*curr)->data;
1008 const struct inferior_data *
1009 register_inferior_data (void)
1011 return register_inferior_data_with_cleanup (NULL);
1015 inferior_alloc_data (struct inferior *inf)
1017 gdb_assert (inf->data == NULL);
1018 inf->num_data = inferior_data_registry.num_registrations;
1019 inf->data = XCALLOC (inf->num_data, void *);
1023 inferior_free_data (struct inferior *inf)
1025 gdb_assert (inf->data != NULL);
1026 clear_inferior_data (inf);
1032 clear_inferior_data (struct inferior *inf)
1034 struct inferior_data_registration *registration;
1037 gdb_assert (inf->data != NULL);
1039 for (registration = inferior_data_registry.registrations, i = 0;
1041 registration = registration->next, i++)
1042 if (inf->data[i] != NULL && registration->data->cleanup)
1043 registration->data->cleanup (inf, inf->data[i]);
1045 memset (inf->data, 0, inf->num_data * sizeof (void *));
1049 set_inferior_data (struct inferior *inf,
1050 const struct inferior_data *data,
1053 gdb_assert (data->index < inf->num_data);
1054 inf->data[data->index] = value;
1058 inferior_data (struct inferior *inf, const struct inferior_data *data)
1060 gdb_assert (data->index < inf->num_data);
1061 return inf->data[data->index];
1065 initialize_inferiors (void)
1067 /* There's always one inferior. Note that this function isn't an
1068 automatic _initialize_foo function, since other _initialize_foo
1069 routines may need to install their per-inferior data keys. We
1070 can only allocate an inferior when all those modules have done
1071 that. Do this after initialize_progspace, due to the
1072 current_program_space reference. */
1074 /* However, when invoked by DragonFly kgdb which always has many inferiors,
1075 the default inferior will not be defined. The swapper process always has
1076 pid 0, which conflicts with the default. */
1078 if (!kernel_debugger) {
1079 current_inferior_ = add_inferior (0);
1080 current_inferior_->pspace = current_program_space;
1081 current_inferior_->aspace = current_program_space->aspace;
1084 add_info ("inferiors", info_inferiors_command,
1085 _("IDs of specified inferiors (all inferiors if no argument)."));
1087 add_com ("add-inferior", no_class, add_inferior_command, _("\
1088 Add a new inferior.\n\
1089 Usage: add-inferior [-copies <N>] [-exec <FILENAME>]\n\
1090 N is the optional number of inferiors to add, default is 1.\n\
1091 FILENAME is the file name of the executable to use\n\
1092 as main program."));
1094 add_com ("remove-inferiors", no_class, remove_inferior_command, _("\
1095 Remove inferior ID (or list of IDs).\n\
1096 Usage: remove-inferiors ID..."));
1098 add_com ("clone-inferior", no_class, clone_inferior_command, _("\
1099 Clone inferior ID.\n\
1100 Usage: clone-inferior [-copies <N>] [ID]\n\
1101 Add N copies of inferior ID. The new inferior has the same\n\
1102 executable loaded as the copied inferior. If -copies is not specified,\n\
1103 adds 1 copy. If ID is not specified, it is the current inferior\n\
1106 add_cmd ("inferiors", class_run, detach_inferior_command, _("\
1107 Detach from inferior ID (or list of IDS)."),
1110 add_cmd ("inferiors", class_run, kill_inferior_command, _("\
1111 Kill inferior ID (or list of IDs)."),
1114 add_cmd ("inferior", class_run, inferior_command, _("\
1115 Use this command to switch between inferiors.\n\
1116 The new inferior ID must be currently known."),
1119 add_setshow_boolean_cmd ("inferior-events", no_class,
1120 &print_inferior_events, _("\
1121 Set printing of inferior events (e.g., inferior start and exit)."), _("\
1122 Show printing of inferior events (e.g., inferior start and exit)."), NULL,
1124 show_print_inferior_events,
1125 &setprintlist, &showprintlist);