X-Git-Url: http://git.efficios.com/?a=blobdiff_plain;f=gdb%2Finflow.c;h=9ec45dd09015e11b811190921a2cf2781071f446;hb=295fa3cfd2f5b3093a86840d567a0b5baf4e3aa2;hp=698cfb4f8be48f8a8494102b442f3bc58cddf31e;hpb=7d9884b92772d5b4fa0de57de5caca2d9308c16c;p=deliverable%2Fbinutils-gdb.git

diff --git a/gdb/inflow.c b/gdb/inflow.c
index 698cfb4f8b..9ec45dd090 100644
--- a/gdb/inflow.c
+++ b/gdb/inflow.c
@@ -1,152 +1,324 @@
 /* Low level interface to ptrace, for GDB when running under Unix.
-   Copyright (C) 1986, 1987, 1989, 1991 Free Software Foundation, Inc.
+   Copyright (C) 1986, 1987, 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995,
+   1996, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008,
+   2009 Free Software Foundation, Inc.
 
-This file is part of GDB.
+   This file is part of GDB.
 
-This program is free software; you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation; either version 2 of the License, or
-(at your option) any later version.
+   This program is free software; you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation; either version 3 of the License, or
+   (at your option) any later version.
 
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
 
-You should have received a copy of the GNU General Public License
-along with this program; if not, write to the Free Software
-Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.  */
+   You should have received a copy of the GNU General Public License
+   along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
 
-#include <stdio.h>
 #include "defs.h"
 #include "frame.h"
 #include "inferior.h"
 #include "command.h"
-#include "signals.h"
+#include "serial.h"
 #include "terminal.h"
 #include "target.h"
+#include "gdbthread.h"
+#include "observer.h"
 
-#ifdef USG
-#include <sys/types.h>
-#endif
-
-/* Some USG-esque systems (some of which are BSD-esque enough so that USG
-   is not defined) want this header, and it won't do any harm.  */
+#include "gdb_string.h"
+#include <signal.h>
 #include <fcntl.h>
+#include "gdb_select.h"
 
-#include <sys/param.h>
-#include <sys/dir.h>
-#include <signal.h>
+#include "inflow.h"
+
+#ifdef HAVE_SYS_IOCTL_H
+#include <sys/ioctl.h>
+#endif
+
+#ifndef O_NOCTTY
+#define O_NOCTTY 0
+#endif
 
-extern struct target_ops child_ops;
+#if defined (SIGIO) && defined (FASYNC) && defined (FD_SET) && defined (F_SETOWN)
+static void handle_sigio (int);
+#endif
 
-/* Nonzero if we are debugging an attached outside process
-   rather than an inferior.  */
+extern void _initialize_inflow (void);
 
-int attach_flag;
+static void pass_signal (int);
 
+static void terminal_ours_1 (int);
 
 /* Record terminal status separately for debugger and inferior.  */
 
-static TERMINAL sg_inferior;
-static TERMINAL sg_ours;
+static struct serial *stdin_serial;
 
-static int tflags_inferior;
-static int tflags_ours;
+/* 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;
 
-#if defined(TIOCGETC) && !defined(TIOCGETC_BROKEN)
-static struct tchars tc_inferior;
-static struct tchars tc_ours;
-#endif
+  /* TTY state.  We save it whenever the inferior stops, and restore
+     it when it resumes.  */
+  serial_ttystate ttystate;
 
-#if defined(TIOCGLTC) && !defined(TIOCGLTC_BROKEN)
-static struct ltchars ltc_inferior;
-static struct ltchars ltc_ours;
+#ifdef PROCESS_GROUP_TYPE
+  /* Process group.  Saved and restored just like ttystate.  */
+  PROCESS_GROUP_TYPE process_group;
 #endif
 
-#ifdef TIOCLGET
-static int lmode_inferior;
-static int lmode_ours;
+  /* fcntl flags.  Saved and restored just like ttystate.  */
+  int tflags;
+};
+
+/* 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;
+
+#ifdef PROCESS_GROUP_TYPE
+
+/* Return the process group of the current inferior.  */
+
+PROCESS_GROUP_TYPE
+inferior_process_group (void)
+{
+  return current_inferior ()->terminal_info->process_group;
+}
 #endif
 
-#ifdef TIOCGPGRP
-# ifdef SHORT_PGRP
-static short pgrp_inferior;
-static short pgrp_ours;
-# else
-static int pgrp_inferior;
-static int pgrp_ours;
-# endif
-#else
+/* While the inferior is running, we want SIGINT and SIGQUIT to go to the
+   inferior only.  If we have job control, that takes care of it.  If not,
+   we save our handlers in these two variables and set SIGINT and SIGQUIT
+   to SIG_IGN.  */
+
 static void (*sigint_ours) ();
 static void (*sigquit_ours) ();
-#endif /* TIOCGPGRP */
 
-/* Copy of inferior_io_terminal when inferior was last started.  */
-static char *inferior_thisrun_terminal;
+/* 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;
 
-static void terminal_ours_1 ();
+/* Nonzero if our terminal settings are in effect.  Zero if the
+   inferior's settings are in effect.  Ignored if !gdb_has_a_terminal
+   ().  */
 
-/* Nonzero if our terminal settings are in effect.
-   Zero if the inferior's settings are in effect.  */
-static int terminal_is_ours;
+int terminal_is_ours;
+
+#ifdef PROCESS_GROUP_TYPE
+static PROCESS_GROUP_TYPE
+gdb_getpgrp (void)
+{
+  int process_group = -1;
+#ifdef HAVE_TERMIOS
+  process_group = tcgetpgrp (0);
+#endif
+#ifdef HAVE_TERMIO
+  process_group = getpgrp ();
+#endif
+#ifdef HAVE_SGTTY
+  ioctl (0, TIOCGPGRP, &process_group);
+#endif
+  return process_group;
+}
+#endif
+
+enum
+  {
+    yes, no, have_not_checked
+  }
+gdb_has_a_terminal_flag = have_not_checked;
+
+/* Does GDB have a terminal (on stdin)?  */
+int
+gdb_has_a_terminal (void)
+{
+  switch (gdb_has_a_terminal_flag)
+    {
+    case yes:
+      return 1;
+    case no:
+      return 0;
+    case have_not_checked:
+      /* Get all the current tty settings (including whether we have a
+         tty at all!).  Can't do this in _initialize_inflow because
+         serial_fdopen() won't work until the serial_ops_list is
+         initialized.  */
+
+#ifdef F_GETFL
+      our_terminal_info.tflags = fcntl (0, F_GETFL, 0);
+#endif
+
+      gdb_has_a_terminal_flag = no;
+      if (stdin_serial != NULL)
+	{
+	  our_terminal_info.ttystate = serial_get_tty_state (stdin_serial);
+
+	  if (our_terminal_info.ttystate != NULL)
+	    {
+	      gdb_has_a_terminal_flag = yes;
+#ifdef PROCESS_GROUP_TYPE
+	      our_terminal_info.process_group = gdb_getpgrp ();
+#endif
+	    }
+	}
+
+      return gdb_has_a_terminal_flag == yes;
+    default:
+      /* "Can't happen".  */
+      return 0;
+    }
+}
+
+/* Macro for printing errors from ioctl operations */
+
+#define	OOPSY(what)	\
+  if (result == -1)	\
+    fprintf_unfiltered(gdb_stderr, "[%s failed in terminal_inferior: %s]\n", \
+	    what, safe_strerror (errno))
+
+static void terminal_ours_1 (int);
 
 /* Initialize the terminal settings we record for the inferior,
    before we actually run the inferior.  */
 
 void
-terminal_init_inferior ()
+terminal_init_inferior_with_pgrp (int pgrp)
 {
-  sg_inferior = sg_ours;
-  tflags_inferior = tflags_ours;
+  if (gdb_has_a_terminal ())
+    {
+      struct inferior *inf = current_inferior ();
 
-#if defined(TIOCGETC) && !defined(TIOCGETC_BROKEN)
-  tc_inferior = tc_ours;
-#endif
+      /* We could just as well copy our_ttystate (if we felt like
+         adding a new function serial_copy_tty_state()).  */
+      xfree (inf->terminal_info->ttystate);
+      inf->terminal_info->ttystate
+	= serial_get_tty_state (stdin_serial);
 
-#if defined(TIOCGLTC) && !defined(TIOCGLTC_BROKEN)
-  ltc_inferior = ltc_ours;
+#ifdef PROCESS_GROUP_TYPE
+      inf->terminal_info->process_group = pgrp;
 #endif
 
-#ifdef TIOCLGET
-  lmode_inferior = lmode_ours;
-#endif
+      /* Make sure that next time we call terminal_inferior (which will be
+         before the program runs, as it needs to be), we install the new
+         process group.  */
+      terminal_is_ours = 1;
+    }
+}
 
-#ifdef TIOCGPGRP
-  pgrp_inferior = inferior_pid;
-#endif /* TIOCGPGRP */
+/* Save the terminal settings again.  This is necessary for the TUI
+   when it switches to TUI or non-TUI mode;  curses changes the terminal
+   and gdb must be able to restore it correctly.  */
 
-  terminal_is_ours = 1;
+void
+terminal_save_ours (void)
+{
+  if (gdb_has_a_terminal ())
+    {
+      /* We could just as well copy our_ttystate (if we felt like adding
+         a new function serial_copy_tty_state).  */
+      xfree (our_terminal_info.ttystate);
+      our_terminal_info.ttystate = serial_get_tty_state (stdin_serial);
+    }
+}
+
+void
+terminal_init_inferior (void)
+{
+#ifdef PROCESS_GROUP_TYPE
+  /* This is for Lynx, and should be cleaned up by having Lynx be a separate
+     debugging target with a version of target_terminal_init_inferior which
+     passes in the process group to a generic routine which does all the work
+     (and the non-threaded child_terminal_init_inferior can just pass in
+     inferior_ptid to the same routine).  */
+  /* We assume INFERIOR_PID is also the child's process group.  */
+  terminal_init_inferior_with_pgrp (PIDGET (inferior_ptid));
+#endif /* PROCESS_GROUP_TYPE */
 }
 
 /* Put the inferior's terminal settings into effect.
    This is preparation for starting or resuming the inferior.  */
 
 void
-terminal_inferior ()
+terminal_inferior (void)
 {
-  if (terminal_is_ours && inferior_thisrun_terminal == 0)
+  struct inferior *inf;
+
+  if (!terminal_is_ours)
+    return;
+
+  inf = current_inferior ();
+
+  if (gdb_has_a_terminal ()
+      && inf->terminal_info->ttystate != NULL
+      && inf->terminal_info->run_terminal == NULL)
     {
-      fcntl (0, F_SETFL, tflags_inferior);
-      fcntl (0, F_SETFL, tflags_inferior);
-      ioctl (0, TIOCSETN, &sg_inferior);
+      int result;
+
+#ifdef F_GETFL
+      /* 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, inf->terminal_info->tflags);
+      result = fcntl (0, F_SETFL, inf->terminal_info->tflags);
+      OOPSY ("fcntl F_SETFL");
+#endif
 
-#if defined(TIOCGETC) && !defined(TIOCGETC_BROKEN)
-      ioctl (0, TIOCSETC, &tc_inferior);
+      /* 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,
+				     inf->terminal_info->ttystate);
+      OOPSY ("setting tty state");
+
+      if (!job_control)
+	{
+	  sigint_ours = (void (*)()) signal (SIGINT, SIG_IGN);
+#ifdef SIGQUIT
+	  sigquit_ours = (void (*)()) signal (SIGQUIT, SIG_IGN);
 #endif
-#if defined(TIOCGLTC) && !defined(TIOCGLTC_BROKEN)
-      ioctl (0, TIOCSLTC, &ltc_inferior);
+	}
+
+      /* If attach_flag is set, we don't know whether we are sharing a
+         terminal with the inferior or not.  (attaching a process
+         without a terminal is one case where we do not; attaching a
+         process which we ran from the same shell as GDB via `&' is
+         one case where we do, I think (but perhaps this is not
+         `sharing' in the sense that we need to save and restore tty
+         state)).  I don't know if there is any way to tell whether we
+         are sharing a terminal.  So what we do is to go through all
+         the saving and restoring of the tty state, but ignore errors
+         setting the process group, which will happen if we are not
+         sharing a terminal).  */
+
+      if (job_control)
+	{
+#ifdef HAVE_TERMIOS
+	  result = tcsetpgrp (0, inf->terminal_info->process_group);
+	  if (!inf->attach_flag)
+	    OOPSY ("tcsetpgrp");
 #endif
-#ifdef TIOCLGET
-      ioctl (0, TIOCLSET, &lmode_inferior);
+
+#ifdef HAVE_SGTTY
+	  result = ioctl (0, TIOCSPGRP, &inf->terminal_info->process_group);
+	  if (!inf->attach_flag)
+	    OOPSY ("TIOCSPGRP");
 #endif
+	}
 
-#ifdef TIOCGPGRP
-      ioctl (0, TIOCSPGRP, &pgrp_inferior);
-#else
-      sigint_ours = (void (*) ()) signal (SIGINT, SIG_IGN);
-      sigquit_ours = (void (*) ()) signal (SIGQUIT, SIG_IGN);
-#endif /* TIOCGPGRP */
     }
   terminal_is_ours = 0;
 }
@@ -160,7 +332,7 @@ terminal_inferior ()
    should be called to get back to a normal state of affairs.  */
 
 void
-terminal_ours_for_output ()
+terminal_ours_for_output (void)
 {
   terminal_ours_1 (1);
 }
@@ -170,143 +342,248 @@ terminal_ours_for_output ()
    so they can be restored properly later.  */
 
 void
-terminal_ours ()
+terminal_ours (void)
 {
   terminal_ours_1 (0);
 }
 
+/* output_only is not used, and should not be used unless we introduce
+   separate terminal_is_ours and terminal_is_ours_for_output
+   flags.  */
+
 static void
-terminal_ours_1 (output_only)
-     int output_only;
+terminal_ours_1 (int output_only)
 {
-#ifdef TIOCGPGRP
-  /* Ignore this signal since it will happen when we try to set the pgrp.  */
-  void (*osigttou) ();
-#endif /* TIOCGPGRP */
+  struct inferior *inf;
 
-  /* The check for inferior_thisrun_terminal had been commented out
-     when the call to ioctl (TIOCNOTTY) was commented out.
-     Checking inferior_thisrun_terminal is necessary so that
+  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.  */
-  if (inferior_thisrun_terminal != 0)
+     to do the ioctl()'s below.  Checking gdb_has_a_terminal
+     avoids attempting all the ioctl's when running in batch.  */
+
+  inf = current_inferior ();
+
+  if (inf->terminal_info->run_terminal != NULL || gdb_has_a_terminal () == 0)
     return;
 
-  if (!terminal_is_ours)
     {
-      terminal_is_ours = 1;
+#ifdef SIGTTOU
+      /* Ignore this signal since it will happen when we try to set the
+         pgrp.  */
+      void (*osigttou) () = NULL;
+#endif
+      int result;
 
-#ifdef TIOCGPGRP
-      osigttou = (void (*) ()) signal (SIGTTOU, SIG_IGN);
+#ifdef SIGTTOU
+      if (job_control)
+	osigttou = (void (*)()) signal (SIGTTOU, SIG_IGN);
+#endif
 
-      ioctl (0, TIOCGPGRP, &pgrp_inferior);
-      ioctl (0, TIOCSPGRP, &pgrp_ours);
+      xfree (inf->terminal_info->ttystate);
+      inf->terminal_info->ttystate = serial_get_tty_state (stdin_serial);
 
-      signal (SIGTTOU, osigttou);
-#else
-      signal (SIGINT, sigint_ours);
-      signal (SIGQUIT, sigquit_ours);
-#endif /* TIOCGPGRP */
+#ifdef PROCESS_GROUP_TYPE
+      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.  */
+	inf->terminal_info->process_group = gdb_getpgrp ();
+#endif
 
-      tflags_inferior = fcntl (0, F_GETFL, 0);
-      ioctl (0, TIOCGETP, &sg_inferior);
+      /* Here we used to set ICANON in our ttystate, but I believe this
+         was an artifact from before when we used readline.  Readline sets
+         the tty state when it needs to.
+         FIXME-maybe: However, query() expects non-raw mode and doesn't
+         use readline.  Maybe query should use readline (on the other hand,
+         this only matters for HAVE_SGTTY, not termio or termios, I think).  */
 
-#if defined(TIOCGETC) && !defined(TIOCGETC_BROKEN)
-      ioctl (0, TIOCGETC, &tc_inferior);
+      /* Set tty state to our_ttystate.  We don't change in our out of raw
+         mode, to avoid flushing input.  We need to do the same thing
+         regardless of output_only, because we don't have separate
+         terminal_is_ours and terminal_is_ours_for_output flags.  It's OK,
+         though, since readline will deal with raw mode when/if it needs to.
+       */
+
+      serial_noflush_set_tty_state (stdin_serial, our_terminal_info.ttystate,
+				    inf->terminal_info->ttystate);
+
+      if (job_control)
+	{
+#ifdef HAVE_TERMIOS
+	  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
+	     used to check for an error here, so perhaps there are other
+	     such situations as well.  */
+	  if (result == -1)
+	    fprintf_unfiltered (gdb_stderr, "[tcsetpgrp failed in terminal_ours: %s]\n",
+				safe_strerror (errno));
 #endif
-#if defined(TIOCGLTC) && !defined(TIOCGLTC_BROKEN)
-      ioctl (0, TIOCGLTC, &ltc_inferior);
+#endif /* termios */
+
+#ifdef HAVE_SGTTY
+	  result = ioctl (0, TIOCSPGRP, &our_terminal_info.process_group);
 #endif
-#ifdef TIOCLGET
-      ioctl (0, TIOCLGET, &lmode_inferior);
+	}
+
+#ifdef SIGTTOU
+      if (job_control)
+	signal (SIGTTOU, osigttou);
 #endif
-    }
 
-#ifdef HAVE_TERMIO
-  sg_ours.c_lflag |= ICANON;
-  if (output_only && !(sg_inferior.c_lflag & ICANON))
-    sg_ours.c_lflag &= ~ICANON;
-#else /* not HAVE_TERMIO */
-  sg_ours.sg_flags &= ~RAW & ~CBREAK;
-  if (output_only)
-    sg_ours.sg_flags |= (RAW | CBREAK) & sg_inferior.sg_flags;
-#endif /* not HAVE_TERMIO */
+      if (!job_control)
+	{
+	  signal (SIGINT, sigint_ours);
+#ifdef SIGQUIT
+	  signal (SIGQUIT, sigquit_ours);
+#endif
+	}
 
-  fcntl (0, F_SETFL, tflags_ours);
-  fcntl (0, F_SETFL, tflags_ours);
-  ioctl (0, TIOCSETN, &sg_ours);
+#ifdef F_GETFL
+      inf->terminal_info->tflags = fcntl (0, F_GETFL, 0);
 
-#if defined(TIOCGETC) && !defined(TIOCGETC_BROKEN)
-  ioctl (0, TIOCSETC, &tc_ours);
-#endif
-#if defined(TIOCGLTC) && !defined(TIOCGLTC_BROKEN)
-  ioctl (0, TIOCSLTC, &ltc_ours);
-#endif
-#ifdef TIOCLGET
-  ioctl (0, TIOCLSET, &lmode_ours);
+      /* 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, our_terminal_info.tflags);
+      result = fcntl (0, F_SETFL, our_terminal_info.tflags);
 #endif
+    }
+}
 
-#ifdef HAVE_TERMIO
-  sg_ours.c_lflag |= ICANON;
-#else /* not HAVE_TERMIO */
-  sg_ours.sg_flags &= ~RAW & ~CBREAK;
-#endif /* not HAVE_TERMIO */
+/* This is a "new_inferior" observer.  It's business is to allocate
+   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 has just been added to
+   the inferior list.  */
+
+static void
+inflow_new_inferior (int pid)
+{
+  struct inferior *inf = find_inferior_pid (pid);
+
+  inf->terminal_info = XZALLOC (struct terminal_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);
+
+  xfree (inf->terminal_info->run_terminal);
+  xfree (inf->terminal_info);
+  inf->terminal_info = NULL;
 }
 
-/* ARGSUSED */
 void
-term_info (arg, from_tty)
-     char *arg;
-     int from_tty;
+copy_terminal_info (struct inferior *to, struct inferior *from)
+{
+  *to->terminal_info = *from->terminal_info;
+  if (from->terminal_info->run_terminal)
+    to->terminal_info->run_terminal
+      = xstrdup (from->terminal_info->run_terminal);
+}
+
+void
+term_info (char *arg, int from_tty)
 {
   target_terminal_info (arg, from_tty);
 }
 
-/* ARGSUSED */
 void
-child_terminal_info (args, from_tty)
-     char *args;
-     int from_tty;
+child_terminal_info (char *args, int from_tty)
 {
-  register int i;
+  struct inferior *inf;
 
-  printf_filtered ("Inferior's terminal status (currently saved by GDB):\n");
+  if (!gdb_has_a_terminal ())
+    {
+      printf_filtered (_("This GDB does not control a terminal.\n"));
+      return;
+    }
 
-#ifdef HAVE_TERMIO
+  if (ptid_equal (inferior_ptid, null_ptid))
+    return;
+
+  inf = current_inferior ();
 
-  printf_filtered ("fcntl flags = 0x%x, c_iflag = 0x%x, c_oflag = 0x%x,\n",
-	  tflags_inferior, sg_inferior.c_iflag, sg_inferior.c_oflag);
-  printf_filtered ("c_cflag = 0x%x, c_lflag = 0x%x, c_line = 0x%x.\n",
-	  sg_inferior.c_cflag, sg_inferior.c_lflag, sg_inferior.c_line);
-  printf_filtered ("c_cc: ");
-  for (i = 0; (i < NCC); i += 1)
-    printf_filtered ("0x%x ", sg_inferior.c_cc[i]);
-  printf_filtered ("\n");
+  printf_filtered (_("Inferior's terminal status (currently saved by GDB):\n"));
 
-#else /* not HAVE_TERMIO */
+  /* First the fcntl flags.  */
+  {
+    int flags;
 
-  printf_filtered ("fcntl flags = 0x%x, sgttyb.sg_flags = 0x%x, owner pid = %d.\n",
-	  tflags_inferior, sg_inferior.sg_flags, pgrp_inferior);
+    flags = inf->terminal_info->tflags;
 
-#endif /* not HAVE_TERMIO */
+    printf_filtered ("File descriptor flags = ");
 
-#if defined(TIOCGETC) && !defined(TIOCGETC_BROKEN)
-  printf_filtered ("tchars: ");
-  for (i = 0; i < (int)sizeof (struct tchars); i++)
-    printf_filtered ("0x%x ", ((char *)&tc_inferior)[i]);
-  printf_filtered ("\n");
+#ifndef O_ACCMODE
+#define O_ACCMODE (O_RDONLY | O_WRONLY | O_RDWR)
+#endif
+    /* (O_ACCMODE) parens are to avoid Ultrix header file bug */
+    switch (flags & (O_ACCMODE))
+      {
+      case O_RDONLY:
+	printf_filtered ("O_RDONLY");
+	break;
+      case O_WRONLY:
+	printf_filtered ("O_WRONLY");
+	break;
+      case O_RDWR:
+	printf_filtered ("O_RDWR");
+	break;
+      }
+    flags &= ~(O_ACCMODE);
+
+#ifdef O_NONBLOCK
+    if (flags & O_NONBLOCK)
+      printf_filtered (" | O_NONBLOCK");
+    flags &= ~O_NONBLOCK;
 #endif
 
-#if defined(TIOCGLTC) && !defined(TIOCGLTC_BROKEN)
-  printf_filtered ("ltchars: ");
-  for (i = 0; i < (int)sizeof (struct ltchars); i++)
-    printf_filtered ("0x%x ", ((char *)&ltc_inferior)[i]);
-  printf_filtered ("\n");
+#if defined (O_NDELAY)
+    /* If O_NDELAY and O_NONBLOCK are defined to the same thing, we will
+       print it as O_NONBLOCK, which is good cause that is what POSIX
+       has, and the flag will already be cleared by the time we get here.  */
+    if (flags & O_NDELAY)
+      printf_filtered (" | O_NDELAY");
+    flags &= ~O_NDELAY;
 #endif
-  
-#ifdef TIOCLGET
-  printf_filtered ("lmode:  0x%x\n", lmode_inferior);
+
+    if (flags & O_APPEND)
+      printf_filtered (" | O_APPEND");
+    flags &= ~O_APPEND;
+
+#if defined (O_BINARY)
+    if (flags & O_BINARY)
+      printf_filtered (" | O_BINARY");
+    flags &= ~O_BINARY;
 #endif
+
+    if (flags)
+      printf_filtered (" | 0x%x", flags);
+    printf_filtered ("\n");
+  }
+
+#ifdef PROCESS_GROUP_TYPE
+  printf_filtered ("Process group = %d\n",
+		   (int) inf->terminal_info->process_group);
+#endif
+
+  serial_print_tty_state (stdin_serial,
+			  inf->terminal_info->ttystate,
+			  gdb_stdout);
 }
 
 /* NEW_TTY_PREFORK is called before forking a new child process,
@@ -319,190 +596,251 @@ child_terminal_info (args, from_tty)
    the terminal specified in the NEW_TTY_PREFORK call.  */
 
 void
-new_tty_prefork (ttyname)
-     char *ttyname;
+new_tty_prefork (const char *ttyname)
 {
   /* Save the name for later, for determining whether we and the child
      are sharing a tty.  */
   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 ()
+new_tty (void)
 {
-  register int tty;
+  int tty;
 
   if (inferior_thisrun_terminal == 0)
     return;
-
+#if !defined(__GO32__) && !defined(_WIN32)
 #ifdef TIOCNOTTY
-  /* Disconnect the child process from our controlling terminal.  */
-  tty = open("/dev/tty", O_RDWR);
+  /* Disconnect the child process from our controlling terminal.  On some
+     systems (SVR4 for example), this may cause a SIGTTOU, so temporarily
+     ignore SIGTTOU. */
+  tty = open ("/dev/tty", O_RDWR);
   if (tty > 0)
     {
-      ioctl(tty, TIOCNOTTY, 0);
-      close(tty);
+      void (*osigttou) ();
+
+      osigttou = (void (*)()) signal (SIGTTOU, SIG_IGN);
+      ioctl (tty, TIOCNOTTY, 0);
+      close (tty);
+      signal (SIGTTOU, osigttou);
     }
 #endif
 
   /* Now open the specified new terminal.  */
-
-#ifdef USE_O_NOCTTY
-  tty = open(inferior_thisrun_terminal, O_RDWR | O_NOCTTY);
-#else
-  tty = open(inferior_thisrun_terminal, O_RDWR);
-#endif
-  if (tty == -1)
-    {
-      print_sys_errmsg (inferior_thisrun_terminal, errno);
-      _exit(1);
-    }
+  tty = open (inferior_thisrun_terminal, O_RDWR | O_NOCTTY);
+  check_syscall (inferior_thisrun_terminal, tty);
 
   /* Avoid use of dup2; doesn't exist on all systems.  */
   if (tty != 0)
-    { close (0); dup (tty); }
+    {
+      close (0);
+      check_syscall ("dup'ing tty into fd 0", dup (tty));
+    }
   if (tty != 1)
-    { close (1); dup (tty); }
+    {
+      close (1);
+      check_syscall ("dup'ing tty into fd 1", dup (tty));
+    }
   if (tty != 2)
-    { close (2); dup (tty); }
+    {
+      close (2);
+      check_syscall ("dup'ing tty into fd 2", dup (tty));
+    }
+
+#ifdef TIOCSCTTY
+  /* Make tty our new controlling terminal.  */
+  if (ioctl (tty, TIOCSCTTY, 0) == -1)
+    /* Mention GDB in warning because it will appear in the inferior's
+       terminal instead of GDB's.  */
+    warning ("GDB: Failed to set controlling terminal: %s",
+	     safe_strerror (errno));
+#endif
+
   if (tty > 2)
-    close(tty);
+    close (tty);
+#endif /* !go32 && !win32 */
 }
+
+/* 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.  */
+
+void
+new_tty_postfork (void)
+{
+  /* Save the name for later, for determining whether we and the child
+     are sharing a tty.  */
+
+  if (inferior_thisrun_terminal)
+    current_inferior ()->terminal_info->run_terminal
+      = xstrdup (inferior_thisrun_terminal);
+
+  inferior_thisrun_terminal = NULL;
+}
+
 
-/* Kill the inferior process.  Make us have no inferior.  */
+/* Call set_sigint_trap when you need to pass a signal on to an attached
+   process when handling SIGINT */
 
-/* ARGSUSED */
 static void
-kill_command (arg, from_tty)
-     char *arg;
-     int from_tty;
+pass_signal (int signo)
 {
-  if (inferior_pid == 0)
-    error ("The program is not being run.");
-  if (!query ("Kill the inferior process? "))
-    error ("Not confirmed.");
-  target_kill (arg, from_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) {
-    printf_filtered ("In %s,\n", current_target->to_longname);
-    if (selected_frame == NULL)
-      fputs_filtered ("No selected stack frame.\n", stdout);
-    else
-      print_stack_frame (selected_frame, selected_frame_level, 1);
-  }
+#ifndef _WIN32
+  kill (PIDGET (inferior_ptid), SIGINT);
+#endif
 }
 
-/* The inferior process has died.  Long live the inferior!  */
+static void (*osig) ();
+static int osig_set;
 
 void
-generic_mourn_inferior ()
+set_sigint_trap (void)
 {
-  inferior_pid = 0;
-  attach_flag = 0;
-  mark_breakpoints_out ();
-  registers_changed ();
-
-#ifdef CLEAR_DEFERRED_STORES
-  /* Delete any pending stores to the inferior... */
-  CLEAR_DEFERRED_STORES;
-#endif
-
-  reopen_exec_file ();
-  if (target_has_stack) {
-    set_current_frame ( create_new_frame (read_register (FP_REGNUM),
-					  read_pc ()));
-    select_frame (get_current_frame (), 0);
-  } else {
-    set_current_frame (0);
-    select_frame ((FRAME) 0, -1);
-  }
-  /* It is confusing to the user for ignore counts to stick around
-     from previous runs of the inferior.  So clear them.  */
-  breakpoint_clear_ignore_counts ();
+  struct inferior *inf = current_inferior ();
+  if (inf->attach_flag || inf->terminal_info->run_terminal)
+    {
+      osig = (void (*)()) signal (SIGINT, pass_signal);
+      osig_set = 1;
+    }
+  else
+    osig_set = 0;
 }
 
 void
-child_mourn_inferior ()
+clear_sigint_trap (void)
 {
-  unpush_target (&child_ops);
-  generic_mourn_inferior ();
+  if (osig_set)
+    {
+      signal (SIGINT, osig);
+      osig_set = 0;
+    }
 }
 
-#if 0 
-/* This function is just for testing, and on some systems (Sony NewsOS
-   3.2) <sys/user.h> also includes <sys/time.h> which leads to errors
-   (since on this system at least sys/time.h is not protected against
-   multiple inclusion).  */
-/* ARGSUSED */
-static void
-try_writing_regs_command (arg, from_tty)
-     char *arg;
-     int from_tty;
+
+/* 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
+   terminal, so a new one is needed if the inferior terminal will be
+   different from GDB's.
+
+   Returns the session id of the new session, 0 if no session was created
+   or -1 if an error occurred.  */
+pid_t
+create_tty_session (void)
+{
+#ifdef HAVE_SETSID
+  pid_t ret;
+
+  if (!job_control || inferior_thisrun_terminal == 0)
+    return 0;
+
+  ret = setsid ();
+  if (ret == -1)
+    warning ("Failed to create new terminal session: setsid: %s",
+	     safe_strerror (errno));
+
+  return ret;
+#else
+  return 0;
+#endif /* HAVE_SETSID */
+}
+
+/* This is here because this is where we figure out whether we (probably)
+   have job control.  Just using job_control only does part of it because
+   setpgid or setpgrp might not exist on a system without job control.
+   It might be considered misplaced (on the other hand, process groups and
+   job control are closely related to ttys).
+
+   For a more clean implementation, in libiberty, put a setpgid which merely
+   calls setpgrp and a setpgrp which does nothing (any system with job control
+   will have one or the other).  */
+int
+gdb_setpgid (void)
 {
-  register int i;
-  register int value;
-
-  if (inferior_pid == 0)
-    error ("There is no inferior process now.");
-
-  /* A Sun 3/50 or 3/60 (at least) running SunOS 4.0.3 will have a
-     kernel panic if we try to write past the end of the user area.
-     Presumably Sun will fix this bug (it has been reported), but it
-     is tacky to crash the system, so at least on SunOS4 we need to
-     stop writing when we hit the end of the user area.  */
-  for (i = 0; i < sizeof (struct user); i += 2)
+  int retval = 0;
+
+  if (job_control)
     {
-      QUIT;
-      errno = 0;
-      value = call_ptrace (3, inferior_pid, i, 0);
-      call_ptrace (6, inferior_pid, i, value);
-      if (errno == 0)
-	{
-	  printf (" Succeeded with address 0x%x; value 0x%x (%d).\n",
-		  i, value, value);
-	}
-      else if ((i & 0377) == 0)
-	printf (" Failed at 0x%x.\n", i);
+#if defined (HAVE_TERMIOS) || defined (TIOCGPGRP)
+#ifdef HAVE_SETPGID
+      /* The call setpgid (0, 0) is supposed to work and mean the same
+         thing as this, but on Ultrix 4.2A it fails with EPERM (and
+         setpgid (getpid (), getpid ()) succeeds).  */
+      retval = setpgid (getpid (), getpid ());
+#else
+#ifdef HAVE_SETPGRP
+#ifdef SETPGRP_VOID 
+      retval = setpgrp ();
+#else
+      retval = setpgrp (getpid (), getpid ());
+#endif
+#endif /* HAVE_SETPGRP */
+#endif /* HAVE_SETPGID */
+#endif /* defined (HAVE_TERMIOS) || defined (TIOCGPGRP) */
     }
+
+  return retval;
 }
-#endif
-
+
+/* Get all the current tty settings (including whether we have a
+   tty at all!).  We can't do this in _initialize_inflow because
+   serial_fdopen() won't work until the serial_ops_list is
+   initialized, but we don't want to do it lazily either, so
+   that we can guarantee stdin_serial is opened if there is
+   a terminal.  */
 void
-_initialize_inflow ()
+initialize_stdin_serial (void)
 {
-  add_info ("terminal", term_info,
-	   "Print inferior's saved terminal status.");
-
-#if 0
-  add_com ("try-writing-regs", class_obscure, try_writing_regs_command,
-	   "Try writing all locations in inferior's system block.\n\
-Report which ones can be written.");
-#endif
+  stdin_serial = serial_fdopen (0);
+}
 
-  add_com ("kill", class_run, kill_command,
-	   "Kill execution of program being debugged.");
+void
+_initialize_inflow (void)
+{
+  add_info ("terminal", term_info,
+	    _("Print inferior's saved terminal status."));
 
-  inferior_pid = 0;
+  terminal_is_ours = 1;
 
-  ioctl (0, TIOCGETP, &sg_ours);
-  tflags_ours = fcntl (0, F_GETFL, 0);
+  /* OK, figure out whether we have job control.  If neither termios nor
+     sgtty (i.e. termio or go32), leave job_control 0.  */
 
-#if defined(TIOCGETC) && !defined(TIOCGETC_BROKEN)
-  ioctl (0, TIOCGETC, &tc_ours);
-#endif
-#if defined(TIOCGLTC) && !defined(TIOCGLTC_BROKEN)
-  ioctl (0, TIOCGLTC, &ltc_ours);
-#endif
-#ifdef TIOCLGET
-  ioctl (0, TIOCLGET, &lmode_ours);
-#endif
+#if defined (HAVE_TERMIOS)
+  /* Do all systems with termios have the POSIX way of identifying job
+     control?  I hope so.  */
+#ifdef _POSIX_JOB_CONTROL
+  job_control = 1;
+#else
+#ifdef _SC_JOB_CONTROL
+  job_control = sysconf (_SC_JOB_CONTROL);
+#else
+  job_control = 0;		/* have to assume the worst */
+#endif /* _SC_JOB_CONTROL */
+#endif /* _POSIX_JOB_CONTROL */
+#endif /* HAVE_TERMIOS */
 
+#ifdef HAVE_SGTTY
 #ifdef TIOCGPGRP
-  ioctl (0, TIOCGPGRP, &pgrp_ours);
+  job_control = 1;
+#else
+  job_control = 0;
 #endif /* TIOCGPGRP */
+#endif /* sgtty */
 
-  terminal_is_ours = 1;
+  observer_attach_new_inferior (inflow_new_inferior);
+  observer_attach_inferior_exit (inflow_inferior_exit);
 }
-