* cygwait.cc (cygwait): Remove lock around sig retrieval since this code is

essentially guarded by thread-specific signal_arrived.
* exceptions.cc (_cygtls::handle_SIGCONT): Simplify.  Eliminate lock/unlock
since code is guarded by signal_arrived.

winsup/cygwin/ChangeLog

@@ -1,3 +1,10 @@
+2013-06-08  Christopher Faylor  <me.cygwin2013@cgf.cx>
+
+	* cygwait.cc (cygwait): Remove lock around sig retrieval since this
+	code is essentially guarded by thread-specific signal_arrived.
+	* exceptions.cc (_cygtls::handle_SIGCONT): Simplify.  Eliminate
+	lock/unlock since code is guarded by signal_arrived.
+
 2013-06-07  Corinna Vinschen  <corinna@vinschen.de>
 
 	* winver.rc (LegalCopyright): Belatedly bump to 2013.

winsup/cygwin/cygwait.cc

@@ -81,11 +81,9 @@ cygwait (HANDLE object, PLARGE_INTEGER timeout, unsigned mask)
 	/* all set */;
       else
 	{
-	  _my_tls.lock ();
 	  int sig = _my_tls.sig;
 	  if (is_cw_sig_cont && sig == SIGCONT)
 	    _my_tls.sig = 0;
-	  _my_tls.unlock ();
 	  if (!sig)
 	    continue;
 	  if (is_cw_sig_eintr || (is_cw_sig_cont && sig == SIGCONT))

winsup/cygwin/exceptions.cc

@@ -1252,38 +1252,28 @@ signal_exit (int sig, siginfo_t *si)
 void
 _cygtls::handle_SIGCONT ()
 {
-  if (ISSTATE (myself, PID_STOPPED))
+  if (NOTSTATE (myself, PID_STOPPED))
-    {
+    return;
-      myself->stopsig = 0;
+
-      myself->process_state &= ~PID_STOPPED;
+  myself->stopsig = 0;
-      int state = 0;
+  myself->process_state &= ~PID_STOPPED;
-      /* Carefully tell sig_handle_tty_stop to wake up.
+  /* Carefully tell sig_handle_tty_stop to wake up.
-	 Make sure that any pending signal is handled before trying to
+     Make sure that any pending signal is handled before trying to
-	 send a new one.  Then make sure that SIGCONT has been recognized
+     send a new one.  Then make sure that SIGCONT has been recognized
-	 before exiting the loop.  */
+     before exiting the loop.  */
-      while (state < 2)
+  bool sigsent = false;
-       {
+  while (1)
-	 lock ();
+    if (sig)		/* Assume that it's ok to just test sig outside of a
-	 bool do_yield = !!sig;
+			   lock since setup_handler does it this way.  */
-	 if (do_yield)
+      yield ();		/* Attempt to schedule another thread.  */
-	   /* signal still being processed */;
+    else if (sigsent)
-	 else if (state)
+      break;		/* SIGCONT has been recognized by other thread */
-	   state++;		/* state == 2: signal no longer being processed */
+    else
-	 else
+      {
-	   {
+	sig = SIGCONT;
-	     sig = SIGCONT;
+	SetEvent (signal_arrived); /* alert sig_handle_tty_stop */
-	     SetEvent (signal_arrived);
+	sigsent = true;
-	     state++;		/* state == 1: alert sig_handle_tty_stop */
+      }
-	     do_yield = true;	/* wake up other thread */
-	   }
-	 unlock ();
-	 if (do_yield)
-	   yield ();
-       }
-      /* Tell wait_sig to handle any queued signals now that we're alive
-	 again. */
-      sig_dispatch_pending (false);
-    }
   /* Clear pending stop signals */
   sig_clear (SIGSTOP);
   sig_clear (SIGTSTP);

winsup/cygwin/fhandler_tty.cc

@@ -96,7 +96,7 @@ fhandler_pty_common::__acquire_output_mutex (const char *fn, int ln,
 {
   if (strace.active ())
     strace.prntf (_STRACE_TERMIOS, fn, "(%d): pty output_mutex (%p): waiting %d ms", ln, output_mutex, ms);
-  if (ms == INFINITE)
+  if (0 && ms == INFINITE)
     ms = 100;
   DWORD res = WaitForSingleObject (output_mutex, ms);
   if (res == WAIT_OBJECT_0)
@@ -145,6 +145,9 @@ fhandler_pty_common::__release_output_mutex (const char *fn, int ln)
 void
 fhandler_pty_master::doecho (const void *str, DWORD len)
 {
+  static char buf[128 * 1024];
+  int buflen = process_slave_output (buf, sizeof (buf), false);
+  puts_readahead (buf, buflen);
   acquire_output_mutex (INFINITE);
   if (!WriteFile (to_master, str, len, &len, NULL))
     termios_printf ("Write to %p failed, %E", to_master);

winsup/cygwin/miscfuncs.cc

@@ -251,10 +251,8 @@ yield ()
       /* MSDN implies that SleepEx will force scheduling of other threads.
 	 Unlike SwitchToThread() the documentation does not mention other
 	 cpus so, presumably (hah!), this + using a lower priority will
-	 stall this thread temporarily and cause another to run.
+	 stall this thread temporarily and cause another to run.  */
-	 Note: Don't use 0 timeout.  This takes a lot of CPU if something
+      SleepEx (0L, false);
-	 goes wrong. */
-      SleepEx (1L, false);
     }
   SetThreadPriority (GetCurrentThread (), prio);
 }