/* Low level interface to ptrace, for GDB when running under Unix.
Copyright (C) 1986, 1987, 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995,
- 1996, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008
- Free Software Foundation, Inc.
+ 1996, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008,
+ 2009, 2010 Free Software Foundation, Inc.
This file is part of GDB.
#include "terminal.h"
#include "target.h"
#include "gdbthread.h"
+#include "observer.h"
#include "gdb_string.h"
#include <signal.h>
static void pass_signal (int);
-static void kill_command (char *, int);
-
static void terminal_ours_1 (int);
\f
/* Record terminal status separately for debugger and inferior. */
static struct serial *stdin_serial;
-/* TTY state for the inferior. We save it whenever the inferior stops, and
- restore it when it resumes. */
-static serial_ttystate inferior_ttystate;
+/* Terminal related info we need to keep track of. Each inferior
+ holds an instance of this structure --- we save it whenever the
+ corresponding inferior stops, and restore it to the foreground
+ inferior when it resumes. */
+struct terminal_info
+{
+ /* The name of the tty (from the `tty' command) that we gave to the
+ inferior when it was started. */
+ char *run_terminal;
+
+ /* TTY state. We save it whenever the inferior stops, and restore
+ it when it resumes. */
+ serial_ttystate ttystate;
+
+#ifdef PROCESS_GROUP_TYPE
+ /* Process group. Saved and restored just like ttystate. */
+ PROCESS_GROUP_TYPE process_group;
+#endif
-/* Our own tty state, which we restore every time we need to deal with the
- terminal. We only set it once, when GDB first starts. The settings of
- flags which readline saves and restores and unimportant. */
-static serial_ttystate our_ttystate;
+ /* fcntl flags. Saved and restored just like ttystate. */
+ int tflags;
+};
-/* fcntl flags for us and the inferior. Saved and restored just like
- {our,inferior}_ttystate. */
-static int tflags_inferior;
-static int tflags_ours;
+/* Our own tty state, which we restore every time we need to deal with
+ the terminal. This is only set once, when GDB first starts. The
+ settings of flags which readline saves and restores and
+ unimportant. */
+static struct terminal_info our_terminal_info;
+
+static struct terminal_info *get_inflow_inferior_data (struct inferior *);
#ifdef PROCESS_GROUP_TYPE
-/* Process group for us and the inferior. Saved and restored just like
- {our,inferior}_ttystate. */
-PROCESS_GROUP_TYPE our_process_group;
-PROCESS_GROUP_TYPE inferior_process_group;
+
+/* Return the process group of the current inferior. */
+
+PROCESS_GROUP_TYPE
+inferior_process_group (void)
+{
+ return get_inflow_inferior_data (current_inferior ())->process_group;
+}
#endif
/* While the inferior is running, we want SIGINT and SIGQUIT to go to the
static void (*sigint_ours) ();
static void (*sigquit_ours) ();
-/* The name of the tty (from the `tty' command) that we gave to the inferior
- when it was last started. */
-
+/* The name of the tty (from the `tty' command) that we're giving to
+ the inferior when starting it up. This is only (and should only
+ be) used as a transient global by new_tty_prefork,
+ create_tty_session, new_tty and new_tty_postfork, all called from
+ fork_inferior, while forking a new child. */
static const char *inferior_thisrun_terminal;
/* Nonzero if our terminal settings are in effect. Zero if the
initialized. */
#ifdef F_GETFL
- tflags_ours = fcntl (0, F_GETFL, 0);
+ our_terminal_info.tflags = fcntl (0, F_GETFL, 0);
#endif
gdb_has_a_terminal_flag = no;
if (stdin_serial != NULL)
{
- our_ttystate = serial_get_tty_state (stdin_serial);
+ our_terminal_info.ttystate = serial_get_tty_state (stdin_serial);
- if (our_ttystate != NULL)
+ if (our_terminal_info.ttystate != NULL)
{
gdb_has_a_terminal_flag = yes;
#ifdef PROCESS_GROUP_TYPE
- our_process_group = gdb_getpgrp ();
+ our_terminal_info.process_group = gdb_getpgrp ();
#endif
}
}
{
if (gdb_has_a_terminal ())
{
+ struct inferior *inf = current_inferior ();
+ struct terminal_info *tinfo = get_inflow_inferior_data (inf);
+
/* We could just as well copy our_ttystate (if we felt like
adding a new function serial_copy_tty_state()). */
- if (inferior_ttystate)
- xfree (inferior_ttystate);
- inferior_ttystate = serial_get_tty_state (stdin_serial);
+ xfree (tinfo->ttystate);
+ tinfo->ttystate = serial_get_tty_state (stdin_serial);
#ifdef PROCESS_GROUP_TYPE
- inferior_process_group = pgrp;
+ tinfo->process_group = pgrp;
#endif
/* Make sure that next time we call terminal_inferior (which will be
{
/* We could just as well copy our_ttystate (if we felt like adding
a new function serial_copy_tty_state). */
- if (our_ttystate)
- xfree (our_ttystate);
- our_ttystate = serial_get_tty_state (stdin_serial);
+ xfree (our_terminal_info.ttystate);
+ our_terminal_info.ttystate = serial_get_tty_state (stdin_serial);
}
}
void
terminal_inferior (void)
{
- if (gdb_has_a_terminal () && terminal_is_ours
- && inferior_ttystate != NULL
- && inferior_thisrun_terminal == 0)
+ struct inferior *inf;
+ struct terminal_info *tinfo;
+
+ if (!terminal_is_ours)
+ return;
+
+ inf = current_inferior ();
+ tinfo = get_inflow_inferior_data (inf);
+
+ if (gdb_has_a_terminal ()
+ && tinfo->ttystate != NULL
+ && tinfo->run_terminal == NULL)
{
int result;
/* Is there a reason this is being done twice? It happens both
places we use F_SETFL, so I'm inclined to think perhaps there
is some reason, however perverse. Perhaps not though... */
- result = fcntl (0, F_SETFL, tflags_inferior);
- result = fcntl (0, F_SETFL, tflags_inferior);
+ result = fcntl (0, F_SETFL, tinfo->tflags);
+ result = fcntl (0, F_SETFL, tinfo->tflags);
OOPSY ("fcntl F_SETFL");
#endif
/* Because we were careful to not change in or out of raw mode in
terminal_ours, we will not change in our out of raw mode with
this call, so we don't flush any input. */
- result = serial_set_tty_state (stdin_serial, inferior_ttystate);
+ result = serial_set_tty_state (stdin_serial,
+ tinfo->ttystate);
OOPSY ("setting tty state");
if (!job_control)
if (job_control)
{
#ifdef HAVE_TERMIOS
- result = tcsetpgrp (0, inferior_process_group);
- if (!attach_flag)
+ result = tcsetpgrp (0, tinfo->process_group);
+ if (!inf->attach_flag)
OOPSY ("tcsetpgrp");
#endif
#ifdef HAVE_SGTTY
- result = ioctl (0, TIOCSPGRP, &inferior_process_group);
- if (!attach_flag)
+ result = ioctl (0, TIOCSPGRP, &tinfo->process_group);
+ if (!inf->attach_flag)
OOPSY ("TIOCSPGRP");
#endif
}
static void
terminal_ours_1 (int output_only)
{
- /* Checking inferior_thisrun_terminal is necessary so that
+ struct inferior *inf;
+ struct terminal_info *tinfo;
+
+ if (terminal_is_ours)
+ return;
+
+ terminal_is_ours = 1;
+
+ /* Checking inferior->run_terminal is necessary so that
if GDB is running in the background, it won't block trying
to do the ioctl()'s below. Checking gdb_has_a_terminal
avoids attempting all the ioctl's when running in batch. */
- if (inferior_thisrun_terminal != 0 || gdb_has_a_terminal () == 0)
+
+ inf = current_inferior ();
+ tinfo = get_inflow_inferior_data (inf);
+
+ if (tinfo->run_terminal != NULL || gdb_has_a_terminal () == 0)
return;
- if (!terminal_is_ours)
{
#ifdef SIGTTOU
/* Ignore this signal since it will happen when we try to set the
#endif
int result;
- terminal_is_ours = 1;
-
#ifdef SIGTTOU
if (job_control)
osigttou = (void (*)()) signal (SIGTTOU, SIG_IGN);
#endif
- if (inferior_ttystate)
- xfree (inferior_ttystate);
- inferior_ttystate = serial_get_tty_state (stdin_serial);
+ xfree (tinfo->ttystate);
+ tinfo->ttystate = serial_get_tty_state (stdin_serial);
#ifdef PROCESS_GROUP_TYPE
- if (!attach_flag)
+ if (!inf->attach_flag)
/* If setpgrp failed in terminal_inferior, this would give us
our process group instead of the inferior's. See
terminal_inferior for details. */
- inferior_process_group = gdb_getpgrp ();
+ tinfo->process_group = gdb_getpgrp ();
#endif
/* Here we used to set ICANON in our ttystate, but I believe this
though, since readline will deal with raw mode when/if it needs to.
*/
- serial_noflush_set_tty_state (stdin_serial, our_ttystate,
- inferior_ttystate);
+ serial_noflush_set_tty_state (stdin_serial, our_terminal_info.ttystate,
+ tinfo->ttystate);
if (job_control)
{
#ifdef HAVE_TERMIOS
- result = tcsetpgrp (0, our_process_group);
+ result = tcsetpgrp (0, our_terminal_info.process_group);
#if 0
/* This fails on Ultrix with EINVAL if you run the testsuite
in the background with nohup, and then log out. GDB never
#endif /* termios */
#ifdef HAVE_SGTTY
- result = ioctl (0, TIOCSPGRP, &our_process_group);
+ result = ioctl (0, TIOCSPGRP, &our_terminal_info.process_group);
#endif
}
}
#ifdef F_GETFL
- tflags_inferior = fcntl (0, F_GETFL, 0);
+ tinfo->tflags = fcntl (0, F_GETFL, 0);
/* Is there a reason this is being done twice? It happens both
places we use F_SETFL, so I'm inclined to think perhaps there
is some reason, however perverse. Perhaps not though... */
- result = fcntl (0, F_SETFL, tflags_ours);
- result = fcntl (0, F_SETFL, tflags_ours);
+ result = fcntl (0, F_SETFL, our_terminal_info.tflags);
+ result = fcntl (0, F_SETFL, our_terminal_info.tflags);
#endif
}
}
+/* Per-inferior data key. */
+static const struct inferior_data *inflow_inferior_data;
+
+static void
+inflow_inferior_data_cleanup (struct inferior *inf, void *arg)
+{
+ struct terminal_info *info;
+
+ info = inferior_data (inf, inflow_inferior_data);
+ if (info != NULL)
+ {
+ xfree (info->run_terminal);
+ xfree (info);
+ }
+}
+
+/* Get the current svr4 data. If none is found yet, add it now. This
+ function always returns a valid object. */
+
+static struct terminal_info *
+get_inflow_inferior_data (struct inferior *inf)
+{
+ struct terminal_info *info;
+
+ info = inferior_data (inf, inflow_inferior_data);
+ if (info == NULL)
+ {
+ info = XZALLOC (struct terminal_info);
+ set_inferior_data (inf, inflow_inferior_data, info);
+ }
+
+ return info;
+}
+
+/* This is a "inferior_exit" observer. Releases the TERMINAL_INFO member
+ of the inferior structure. This field is private to inflow.c, and
+ its type is opaque to the rest of GDB. PID is the target pid of
+ the inferior that is about to be removed from the inferior
+ list. */
+
+static void
+inflow_inferior_exit (int pid)
+{
+ struct inferior *inf = find_inferior_pid (pid);
+ struct terminal_info *info;
+
+ info = inferior_data (inf, inflow_inferior_data);
+ if (info != NULL)
+ {
+ xfree (info->run_terminal);
+ xfree (info);
+ set_inferior_data (inf, inflow_inferior_data, NULL);
+ }
+}
+
+void
+copy_terminal_info (struct inferior *to, struct inferior *from)
+{
+ struct terminal_info *tinfo_to, *tinfo_from;
+
+ tinfo_to = get_inflow_inferior_data (to);
+ tinfo_from = get_inflow_inferior_data (from);
+ *tinfo_to = *tinfo_from;
+ if (tinfo_from->run_terminal)
+ tinfo_to->run_terminal
+ = xstrdup (tinfo_from->run_terminal);
+}
+
void
term_info (char *arg, int from_tty)
{
void
child_terminal_info (char *args, int from_tty)
{
+ struct inferior *inf;
+ struct terminal_info *tinfo;
+
if (!gdb_has_a_terminal ())
{
printf_filtered (_("This GDB does not control a terminal.\n"));
return;
}
+ if (ptid_equal (inferior_ptid, null_ptid))
+ return;
+
+ inf = current_inferior ();
+ tinfo = get_inflow_inferior_data (inf);
+
printf_filtered (_("Inferior's terminal status (currently saved by GDB):\n"));
/* First the fcntl flags. */
{
int flags;
- flags = tflags_inferior;
+ flags = tinfo->tflags;
printf_filtered ("File descriptor flags = ");
}
#ifdef PROCESS_GROUP_TYPE
- printf_filtered ("Process group = %d\n",
- (int) inferior_process_group);
+ printf_filtered ("Process group = %d\n", (int) tinfo->process_group);
#endif
- serial_print_tty_state (stdin_serial, inferior_ttystate, gdb_stdout);
+ serial_print_tty_state (stdin_serial, tinfo->ttystate, gdb_stdout);
}
\f
/* NEW_TTY_PREFORK is called before forking a new child process,
inferior_thisrun_terminal = ttyname;
}
+
+/* If RESULT, assumed to be the return value from a system call, is
+ negative, print the error message indicated by errno and exit.
+ MSG should identify the operation that failed. */
+static void
+check_syscall (const char *msg, int result)
+{
+ if (result < 0)
+ {
+ print_sys_errmsg (msg, errno);
+ _exit (1);
+ }
+}
+
void
new_tty (void)
{
/* Now open the specified new terminal. */
tty = open (inferior_thisrun_terminal, O_RDWR | O_NOCTTY);
- if (tty == -1)
- {
- print_sys_errmsg (inferior_thisrun_terminal, errno);
- _exit (1);
- }
+ check_syscall (inferior_thisrun_terminal, tty);
/* Avoid use of dup2; doesn't exist on all systems. */
if (tty != 0)
{
close (0);
- dup (tty);
+ check_syscall ("dup'ing tty into fd 0", dup (tty));
}
if (tty != 1)
{
close (1);
- dup (tty);
+ check_syscall ("dup'ing tty into fd 1", dup (tty));
}
if (tty != 2)
{
close (2);
- dup (tty);
+ check_syscall ("dup'ing tty into fd 2", dup (tty));
}
#ifdef TIOCSCTTY
close (tty);
#endif /* !go32 && !win32 */
}
-\f
-/* Kill the inferior process. Make us have no inferior. */
-
-static void
-kill_command (char *arg, int from_tty)
-{
- /* FIXME: This should not really be inferior_ptid (or target_has_execution).
- It should be a distinct flag that indicates that a target is active, cuz
- some targets don't have processes! */
- if (ptid_equal (inferior_ptid, null_ptid))
- error (_("The program is not being run."));
- if (!query ("Kill the program being debugged? "))
- error (_("Not confirmed."));
- target_kill ();
+/* NEW_TTY_POSTFORK is called after forking a new child process, and
+ adding it to the inferior table, to store the TTYNAME being used by
+ the child, or null if it sharing the terminal with gdb. */
- init_thread_list (); /* Destroy thread info */
+void
+new_tty_postfork (void)
+{
+ /* Save the name for later, for determining whether we and the child
+ are sharing a tty. */
- /* Killing off the inferior can leave us with a core file. If so,
- print the state we are left in. */
- if (target_has_stack)
+ if (inferior_thisrun_terminal)
{
- printf_filtered (_("In %s,\n"), target_longname);
- print_stack_frame (get_selected_frame (NULL), 1, SRC_AND_LOC);
+ struct inferior *inf = current_inferior ();
+ struct terminal_info *tinfo = get_inflow_inferior_data (inf);
+
+ tinfo->run_terminal = xstrdup (inferior_thisrun_terminal);
}
- bfd_cache_close_all ();
+
+ inferior_thisrun_terminal = NULL;
}
+
\f
/* Call set_sigint_trap when you need to pass a signal on to an attached
process when handling SIGINT */
}
static void (*osig) ();
+static int osig_set;
void
set_sigint_trap (void)
{
- if (attach_flag || inferior_thisrun_terminal)
+ struct inferior *inf = current_inferior ();
+ struct terminal_info *tinfo = get_inflow_inferior_data (inf);
+
+ if (inf->attach_flag || tinfo->run_terminal)
{
osig = (void (*)()) signal (SIGINT, pass_signal);
+ osig_set = 1;
}
+ else
+ osig_set = 0;
}
void
clear_sigint_trap (void)
{
- if (attach_flag || inferior_thisrun_terminal)
+ if (osig_set)
{
signal (SIGINT, osig);
+ osig_set = 0;
}
}
\f
-#if defined (SIGIO) && defined (FASYNC) && defined (FD_SET) && defined (F_SETOWN)
-static void (*old_sigio) ();
-
-static void
-handle_sigio (int signo)
-{
- int numfds;
- fd_set readfds;
-
- signal (SIGIO, handle_sigio);
-
- FD_ZERO (&readfds);
- FD_SET (target_activity_fd, &readfds);
- numfds = gdb_select (target_activity_fd + 1, &readfds, NULL, NULL, NULL);
- if (numfds >= 0 && FD_ISSET (target_activity_fd, &readfds))
- {
-#ifndef _WIN32
- if ((*target_activity_function) ())
- kill (PIDGET (inferior_ptid), SIGINT);
-#endif
- }
-}
-
-static int old_fcntl_flags;
-
-void
-set_sigio_trap (void)
-{
- if (target_activity_function)
- {
- old_sigio = (void (*)()) signal (SIGIO, handle_sigio);
- fcntl (target_activity_fd, F_SETOWN, getpid ());
- old_fcntl_flags = fcntl (target_activity_fd, F_GETFL, 0);
- fcntl (target_activity_fd, F_SETFL, old_fcntl_flags | FASYNC);
- }
-}
-
-void
-clear_sigio_trap (void)
-{
- if (target_activity_function)
- {
- signal (SIGIO, old_sigio);
- fcntl (target_activity_fd, F_SETFL, old_fcntl_flags);
- }
-}
-#else /* No SIGIO. */
-void
-set_sigio_trap (void)
-{
- if (target_activity_function)
- internal_error (__FILE__, __LINE__, _("failed internal consistency check"));
-}
-
-void
-clear_sigio_trap (void)
-{
- if (target_activity_function)
- internal_error (__FILE__, __LINE__, _("failed internal consistency check"));
-}
-#endif /* No SIGIO. */
-\f
/* Create a new session if the inferior will run in a different tty.
A session is UNIX's way of grouping processes that share a controlling
add_info ("terminal", term_info,
_("Print inferior's saved terminal status."));
- add_com ("kill", class_run, kill_command,
- _("Kill execution of program being debugged."));
-
- inferior_ptid = null_ptid;
-
terminal_is_ours = 1;
/* OK, figure out whether we have job control. If neither termios nor
job_control = 0;
#endif /* TIOCGPGRP */
#endif /* sgtty */
+
+ observer_attach_inferior_exit (inflow_inferior_exit);
+
+ inflow_inferior_data
+ = register_inferior_data_with_cleanup (inflow_inferior_data_cleanup);
}
projects / deliverable / binutils-gdb.git / blobdiff