1999-03-09 Roland McGrath <roland@baalperazim.frob.com>

	* sysdeps/mach/hurd/ioctl.c (__ioctl): Move the marshalling of the
	arguments into the request message buffer inside `send_rpc'
	subfunction.  We must repeat the marshalling when retrying the RPC
	after a SIGTTOU delivery.

	* hurd/ctty-input.c (_hurd_ctty_input): Use early short-circuit code
	path when there is no ctty port.
	* hurd/ctty-output.c (_hurd_ctty_output): Likewise.
	Move sigstate check inside loop so we recheck after handling a signal.

2 files changed, 69 insertions, 63 deletions

diff --git a/hurd/ctty-input.c b/hurd/ctty-input.c
index 95e0169..10a8461 100644
--- a/hurd/ctty-input.c
+++ b/hurd/ctty-input.c
@@ -1,5 +1,5 @@
 /* _hurd_ctty_input -- Do an input RPC and generate SIGTTIN if necessary.
-   Copyright (C) 1995, 1997 Free Software Foundation, Inc.
+   Copyright (C) 1995,97,99 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
@@ -28,46 +28,49 @@ _hurd_ctty_input (io_t port, io_t ctty, error_t (*rpc) (io_t))
 {
   error_t err;
 
+  if (ctty == MACH_PORT_NULL)
+    return (*rpc) (port);
+
   do
     {
-      err = (*rpc) (ctty != MACH_PORT_NULL ? ctty : port);
-      if (ctty != MACH_PORT_NULL && err == EBACKGROUND)
+      err = (*rpc) (ctty);
+      if (err == EBACKGROUND)
 	{
 	  /* We are a background job and tried to read from the tty.
 	     We should probably get a SIGTTIN signal.  */
-	  struct hurd_sigstate *ss;
 	  if (_hurd_orphaned)
 	    /* Our process group is orphaned.  Don't stop; just fail.  */
 	    err = EIO;
 	  else
 	    {
-	      ss = _hurd_self_sigstate ();
+	      struct hurd_sigstate *ss = _hurd_self_sigstate ();
 	      __spin_lock (&ss->lock);
 	      if (__sigismember (&ss->blocked, SIGTTIN) ||
 		  ss->actions[SIGTTIN].sa_handler == SIG_IGN)
 		/* We are blocking or ignoring SIGTTIN.  Just fail.  */
 		err = EIO;
 	      __spin_unlock (&ss->lock);
-	    }
-	  if (err == EBACKGROUND)
-	    {
-	      /* Send a SIGTTIN signal to our process group.
 
-		 We must remember here not to clobber ERR, since
-		 the loop condition below uses it to recall that
-		 we should retry after a stop.  */
+	      if (err == EBACKGROUND)
+		{
+		  /* Send a SIGTTIN signal to our process group.
 
-	      __USEPORT (CTTYID, _hurd_sig_post (0, SIGTTIN, port));
-	      /* XXX what to do if error here? */
+		     We must remember here not to clobber ERR, since
+		     the loop condition below uses it to recall that
+		  we should retry after a stop.  */
 
-	      /* At this point we should have just run the handler for
-		 SIGTTIN or resumed after being stopped.  Now this is
-		 still a "system call", so check to see if we should
-		 restart it.  */
-	      __spin_lock (&ss->lock);
-	      if (!(ss->actions[SIGTTIN].sa_flags & SA_RESTART))
-		err = EINTR;
-	      __spin_unlock (&ss->lock);
+		  __USEPORT (CTTYID, _hurd_sig_post (0, SIGTTIN, port));
+		  /* XXX what to do if error here? */
+
+		  /* At this point we should have just run the handler for
+		     SIGTTIN or resumed after being stopped.  Now this is
+		     still a "system call", so check to see if we should
+		  restart it.  */
+		  __spin_lock (&ss->lock);
+		  if (!(ss->actions[SIGTTIN].sa_flags & SA_RESTART))
+		    err = EINTR;
+		  __spin_unlock (&ss->lock);
+		}
 	    }
 	}
       /* If the last RPC generated a SIGTTIN, loop to try it again.  */
diff --git a/hurd/ctty-output.c b/hurd/ctty-output.c
index 4bd33ae..70fc254 100644
--- a/hurd/ctty-output.c
+++ b/hurd/ctty-output.c
@@ -1,5 +1,5 @@
 /* _hurd_ctty_output -- Do an output RPC and generate SIGTTOU if necessary.
-   Copyright (C) 1995, 1997 Free Software Foundation, Inc.
+   Copyright (C) 1995,97,99 Free Software Foundation, Inc.
    This file is part of the GNU C Library.
 
    The GNU C Library is free software; you can redistribute it and/or
@@ -26,57 +26,60 @@
 error_t
 _hurd_ctty_output (io_t port, io_t ctty, error_t (*rpc) (io_t))
 {
-  error_t err;
-  struct hurd_sigstate *ss;
-  io_t ioport;
-
-  /* Don't use the ctty io port if we are blocking or ignoring SIGTTOU.  */
   if (ctty == MACH_PORT_NULL)
-    ioport = port;
+    return (*rpc) (port);
   else
     {
-      ss = _hurd_self_sigstate ();
-      __spin_lock (&ss->lock);
-      if (__sigismember (&ss->blocked, SIGTTOU) ||
-	  ss->actions[SIGTTOU].sa_handler == SIG_IGN)
-	ioport = port;
-      else
-	ioport = ctty;
-      __spin_unlock (&ss->lock);
-    }
+      struct hurd_sigstate *ss = _hurd_self_sigstate ();
+      error_t err;
 
-  do
-    {
-      err = (*rpc) (ioport);
-      if (ioport == ctty && err == EBACKGROUND)
+      do
 	{
-	  if (_hurd_orphaned)
-	    /* Our process group is orphaned, so we never generate a
-	       signal; we just fail.  */
+	  /* Don't use the ctty io port if we are blocking or ignoring
+	     SIGTTOU.  We redo this check at the top of the loop in case
+	     the signal handler changed the state.  */
+	  __spin_lock (&ss->lock);
+	  if (__sigismember (&ss->blocked, SIGTTOU) ||
+	      ss->actions[SIGTTOU].sa_handler == SIG_IGN)
 	    err = EIO;
 	  else
+	    err = 0;
+	  __spin_unlock (&ss->lock);
+
+	  if (err)
+	    return (*rpc) (port);
+
+	  err = (*rpc) (ctty);
+	  if (err == EBACKGROUND)
 	    {
-	      /* Send a SIGTTOU signal to our process group.
+	      if (_hurd_orphaned)
+		/* Our process group is orphaned, so we never generate a
+		   signal; we just fail.  */
+		err = EIO;
+	      else
+		{
+		  /* Send a SIGTTOU signal to our process group.
 
-		 We must remember here not to clobber ERR, since
-		 the loop condition below uses it to recall that
-		 we should retry after a stop.  */
+		     We must remember here not to clobber ERR, since
+		     the loop condition below uses it to recall that
+		  we should retry after a stop.  */
 
-	      __USEPORT (CTTYID, _hurd_sig_post (0, SIGTTOU, port));
-	      /* XXX what to do if error here? */
+		  __USEPORT (CTTYID, _hurd_sig_post (0, SIGTTOU, port));
+		  /* XXX what to do if error here? */
 
-	      /* At this point we should have just run the handler for
-		 SIGTTOU or resumed after being stopped.  Now this is
-		 still a "system call", so check to see if we should
-		 restart it.  */
-	      __spin_lock (&ss->lock);
-	      if (!(ss->actions[SIGTTOU].sa_flags & SA_RESTART))
-		err = EINTR;
-	      __spin_unlock (&ss->lock);
+		  /* At this point we should have just run the handler for
+		     SIGTTOU or resumed after being stopped.  Now this is
+		     still a "system call", so check to see if we should
+		  restart it.  */
+		  __spin_lock (&ss->lock);
+		  if (!(ss->actions[SIGTTOU].sa_flags & SA_RESTART))
+		    err = EINTR;
+		  __spin_unlock (&ss->lock);
+		}
 	    }
-	}
-      /* If the last RPC generated a SIGTTOU, loop to try it again.  */
-    } while (err == EBACKGROUND);
+	  /* If the last RPC generated a SIGTTOU, loop to try it again.  */
+	} while (err == EBACKGROUND);
 
-  return err;
+      return err;
+    }
 }