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

diff --git a/gdb/inflow.c b/gdb/inflow.c
index b88e3038b1..9ec45dd090 100644
--- a/gdb/inflow.c
+++ b/gdb/inflow.c
@@ -1,13 +1,13 @@
 /* Low level interface to ptrace, for GDB when running under Unix.
-   Copyright 1986, 1987, 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995,
-   1996, 1998, 1999, 2000, 2001, 2002, 2003, 2004
-   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 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
+   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,
@@ -16,9 +16,7 @@
    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., 59 Temple Place - Suite 330,
-   Boston, MA 02111-1307, USA.  */
+   along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
 
 #include "defs.h"
 #include "frame.h"
@@ -28,13 +26,12 @@
 #include "terminal.h"
 #include "target.h"
 #include "gdbthread.h"
+#include "observer.h"
 
 #include "gdb_string.h"
 #include <signal.h>
 #include <fcntl.h>
-#ifdef HAVE_SYS_SELECT_H
-#include <sys/select.h>
-#endif
+#include "gdb_select.h"
 
 #include "inflow.h"
 
@@ -54,33 +51,50 @@ extern void _initialize_inflow (void);
 
 static void pass_signal (int);
 
-static void kill_command (char *, int);
-
 static void terminal_ours_1 (int);
 
 /* 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;
 
-/* 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;
+  /* TTY state.  We save it whenever the inferior stops, and restore
+     it when it resumes.  */
+  serial_ttystate ttystate;
 
-/* fcntl flags for us and the inferior.  Saved and restored just like
-   {our,inferior}_ttystate.  */
-static int tflags_inferior;
-static int tflags_ours;
+#ifdef PROCESS_GROUP_TYPE
+  /* Process group.  Saved and restored just like ttystate.  */
+  PROCESS_GROUP_TYPE process_group;
+#endif
+
+  /* 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
-/* 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 current_inferior ()->terminal_info->process_group;
+}
 #endif
 
 /* While the inferior is running, we want SIGINT and SIGQUIT to go to the
@@ -91,9 +105,11 @@ PROCESS_GROUP_TYPE inferior_process_group;
 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
@@ -102,6 +118,24 @@ static const char *inferior_thisrun_terminal;
 
 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
@@ -125,26 +159,19 @@ gdb_has_a_terminal (void)
          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;
-      stdin_serial = serial_fdopen (0);
       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 HAVE_TERMIOS
-	      our_process_group = tcgetpgrp (0);
-#endif
-#ifdef HAVE_TERMIO
-	      our_process_group = getpgrp ();
-#endif
-#ifdef HAVE_SGTTY
-	      ioctl (0, TIOCGPGRP, &our_process_group);
+#ifdef PROCESS_GROUP_TYPE
+	      our_terminal_info.process_group = gdb_getpgrp ();
 #endif
 	    }
 	}
@@ -173,14 +200,16 @@ terminal_init_inferior_with_pgrp (int pgrp)
 {
   if (gdb_has_a_terminal ())
     {
+      struct inferior *inf = current_inferior ();
+
       /* 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 (inf->terminal_info->ttystate);
+      inf->terminal_info->ttystate
+	= serial_get_tty_state (stdin_serial);
 
 #ifdef PROCESS_GROUP_TYPE
-      inferior_process_group = pgrp;
+      inf->terminal_info->process_group = pgrp;
 #endif
 
       /* Make sure that next time we call terminal_inferior (which will be
@@ -201,9 +230,8 @@ terminal_save_ours (void)
     {
       /* 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);
     }
 }
 
@@ -227,9 +255,16 @@ terminal_init_inferior (void)
 void
 terminal_inferior (void)
 {
-  if (gdb_has_a_terminal () && terminal_is_ours
-      && inferior_ttystate != NULL
-      && 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)
     {
       int result;
 
@@ -237,15 +272,16 @@ terminal_inferior (void)
       /* 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, inf->terminal_info->tflags);
+      result = fcntl (0, F_SETFL, inf->terminal_info->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,
+				     inf->terminal_info->ttystate);
       OOPSY ("setting tty state");
 
       if (!job_control)
@@ -271,14 +307,14 @@ terminal_inferior (void)
       if (job_control)
 	{
 #ifdef HAVE_TERMIOS
-	  result = tcsetpgrp (0, inferior_process_group);
-	  if (!attach_flag)
+	  result = tcsetpgrp (0, inf->terminal_info->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, &inf->terminal_info->process_group);
+	  if (!inf->attach_flag)
 	    OOPSY ("TIOCSPGRP");
 #endif
 	}
@@ -318,14 +354,23 @@ terminal_ours (void)
 static void
 terminal_ours_1 (int output_only)
 {
-  /* Checking inferior_thisrun_terminal is necessary so that
+  struct inferior *inf;
+
+  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 ();
+
+  if (inf->terminal_info->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
@@ -334,24 +379,20 @@ terminal_ours_1 (int output_only)
 #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);
-#ifdef HAVE_TERMIOS
-      inferior_process_group = tcgetpgrp (0);
-#endif
-#ifdef HAVE_TERMIO
-      inferior_process_group = getpgrp ();
-#endif
-#ifdef HAVE_SGTTY
-      ioctl (0, TIOCGPGRP, &inferior_process_group);
+      xfree (inf->terminal_info->ttystate);
+      inf->terminal_info->ttystate = serial_get_tty_state (stdin_serial);
+
+#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
 
       /* Here we used to set ICANON in our ttystate, but I believe this
@@ -368,13 +409,13 @@ terminal_ours_1 (int output_only)
          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,
+				    inf->terminal_info->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
@@ -387,7 +428,7 @@ terminal_ours_1 (int output_only)
 #endif /* termios */
 
 #ifdef HAVE_SGTTY
-	  result = ioctl (0, TIOCSPGRP, &our_process_group);
+	  result = ioctl (0, TIOCSPGRP, &our_terminal_info.process_group);
 #endif
 	}
 
@@ -405,19 +446,56 @@ terminal_ours_1 (int output_only)
 	}
 
 #ifdef F_GETFL
-      tflags_inferior = fcntl (0, F_GETFL, 0);
+      inf->terminal_info->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
-
-      result = result;		/* lint */
     }
 }
 
+/* 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;
+}
+
+void
+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)
 {
@@ -427,19 +505,26 @@ term_info (char *arg, int from_tty)
 void
 child_terminal_info (char *args, int from_tty)
 {
+  struct inferior *inf;
+
   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 ();
+
   printf_filtered (_("Inferior's terminal status (currently saved by GDB):\n"));
 
   /* First the fcntl flags.  */
   {
     int flags;
 
-    flags = tflags_inferior;
+    flags = inf->terminal_info->tflags;
 
     printf_filtered ("File descriptor flags = ");
 
@@ -493,10 +578,12 @@ child_terminal_info (char *args, int from_tty)
 
 #ifdef PROCESS_GROUP_TYPE
   printf_filtered ("Process group = %d\n",
-		   (int) inferior_process_group);
+		   (int) inf->terminal_info->process_group);
 #endif
 
-  serial_print_tty_state (stdin_serial, inferior_ttystate, gdb_stdout);
+  serial_print_tty_state (stdin_serial,
+			  inf->terminal_info->ttystate,
+			  gdb_stdout);
 }
 
 /* NEW_TTY_PREFORK is called before forking a new child process,
@@ -516,6 +603,20 @@ new_tty_prefork (const char *ttyname)
   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)
 {
@@ -542,62 +643,56 @@ 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
+  /* 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);
 #endif /* !go32 && !win32 */
 }
-
-/* 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! */
+/* 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.  */
 
-  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 ();
+void
+new_tty_postfork (void)
+{
+  /* Save the name for later, for determining whether we and the child
+     are sharing a tty.  */
 
-  init_thread_list ();		/* Destroy thread info */
+  if (inferior_thisrun_terminal)
+    current_inferior ()->terminal_info->run_terminal
+      = xstrdup (inferior_thisrun_terminal);
 
-  /* 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"), target_longname);
-      if (deprecated_selected_frame == NULL)
-	fputs_filtered ("No selected stack frame.\n", gdb_stdout);
-      else
-	print_stack_frame (get_selected_frame (NULL), 1, SRC_AND_LOC);
-    }
-  bfd_cache_close_all ();
+  inferior_thisrun_terminal = NULL;
 }
+
 
 /* Call set_sigint_trap when you need to pass a signal on to an attached
    process when handling SIGINT */
@@ -611,87 +706,58 @@ pass_signal (int signo)
 }
 
 static void (*osig) ();
+static int osig_set;
 
 void
 set_sigint_trap (void)
 {
-  if (attach_flag || inferior_thisrun_terminal)
+  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
 clear_sigint_trap (void)
 {
-  if (attach_flag || inferior_thisrun_terminal)
+  if (osig_set)
     {
       signal (SIGINT, osig);
+      osig_set = 0;
     }
 }
 
-#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 = 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;
+/* 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.
 
-void
-set_sigio_trap (void)
+   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)
 {
-  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);
-    }
-}
+#ifdef HAVE_SETSID
+  pid_t ret;
 
-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"));
-}
+  if (!job_control || inferior_thisrun_terminal == 0)
+    return 0;
 
-void
-clear_sigio_trap (void)
-{
-  if (target_activity_function)
-    internal_error (__FILE__, __LINE__, _("failed internal consistency check"));
+  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 */
 }
-#endif /* No SIGIO.  */
-
 
 /* 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
@@ -730,17 +796,24 @@ gdb_setpgid (void)
   return retval;
 }
 
+/* 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_stdin_serial (void)
+{
+  stdin_serial = serial_fdopen (0);
+}
+
 void
 _initialize_inflow (void)
 {
   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
@@ -767,4 +840,7 @@ _initialize_inflow (void)
   job_control = 0;
 #endif /* TIOCGPGRP */
 #endif /* sgtty */
+
+  observer_attach_new_inferior (inflow_new_inferior);
+  observer_attach_inferior_exit (inflow_inferior_exit);
 }