[binutils-gdb] [GDBserver] Block and unblock SIGIO

[Yao Qi <qiyao at sourceware dot org>]

https://sourceware.org/git/gitweb.cgi?p=binutils-gdb.git;h=8b2073398477b33d425b0570236fe4e4222fe2c4

commit 8b2073398477b33d425b0570236fe4e4222fe2c4
Author: Yao Qi <yao.qi@linaro.org>
Date:   Tue Jan 26 13:50:22 2016 +0000

    [GDBserver] Block and unblock SIGIO
    
    Nowadays, GDBserver disables async io (by ignoring SIGIO) when process
    a serial event, and enables async io (by installing signal handler) when
    resume the inferior and wait.  GDBserver may miss SIGIO (by interrupt)
    and doesn't process SIGIO in time, which is shown by
    gdb.base/interrupt-noterm.exp.  In the test, GDB sends "continue &" and
    then "interrupt".  if '\003' arrives at a period between GDBserver
    receives vCont;c and enables async io, SIGIO is ignored because signal
    handler isn't installed.  GDBserver waits for the inferior and can not
    notice '\003' until it returns from wait.
    
    This patch changes the code to install SIGIO handler early, but block
    and unblock SIGIO as needed.  In this way, we don't remove SIGIO
    handler, so SIGIO can't be ignored.  However, GDBserver needs to
    remove the signal handler when connection is closed.
    
    gdb/gdbserver:
    
    2016-01-26  Yao Qi  <yao.qi@linaro.org>
    
    	* remote-utils.c (remote_close) [!USE_WIN32API]: Ignore SIGIO.
    	(unblock_async_io): Rename to ...
    	(block_unblock_async_io): ... it.  New function.
    	(enable_async_io): Don't install SIGIO handler.  Unblock it
    	instead.
    	(disable_async_io): Don't ignore SIGIO.  Block it instead.
    	(initialize_async_io): Install SIGIO handler.  Don't call
    	unblock_async_io.

Diff:
---
 gdb/gdbserver/ChangeLog      | 11 +++++++++++
 gdb/gdbserver/remote-utils.c | 33 +++++++++++++++++++--------------
 2 files changed, 30 insertions(+), 14 deletions(-)

diff --git a/gdb/gdbserver/ChangeLog b/gdb/gdbserver/ChangeLog
index 4aa7350..0ba902e 100644
--- a/gdb/gdbserver/ChangeLog
+++ b/gdb/gdbserver/ChangeLog
@@ -1,5 +1,16 @@
 2016-01-26  Yao Qi  <yao.qi@linaro.org>
 
+	* remote-utils.c (remote_close) [!USE_WIN32API]: Ignore SIGIO.
+	(unblock_async_io): Rename to ...
+	(block_unblock_async_io): ... it.  New function.
+	(enable_async_io): Don't install SIGIO handler.  Unblock it
+	instead.
+	(disable_async_io): Don't ignore SIGIO.  Block it instead.
+	(initialize_async_io): Install SIGIO handler.  Don't call
+	unblock_async_io.
+
+2016-01-26  Yao Qi  <yao.qi@linaro.org>
+
 	* remote-utils.c (getpkt): If the buffer isn't empty, and the
 	first character is '\003', call *the_target->request_interrupt.
 
diff --git a/gdb/gdbserver/remote-utils.c b/gdb/gdbserver/remote-utils.c
index ccc99f1..e751473 100644
--- a/gdb/gdbserver/remote-utils.c
+++ b/gdb/gdbserver/remote-utils.c
@@ -402,6 +402,11 @@ remote_close (void)
 {
   delete_file_handler (remote_desc);
 
+#ifndef USE_WIN32API
+  /* Remove SIGIO handler.  */
+  signal (SIGIO, SIG_IGN);
+#endif
+
 #ifdef USE_WIN32API
   closesocket (remote_desc);
 #else
@@ -775,19 +780,19 @@ check_remote_input_interrupt_request (void)
   input_interrupt (0);
 }
 
-/* Asynchronous I/O support.  SIGIO must be enabled when waiting, in order to
-   accept Control-C from the client, and must be disabled when talking to
-   the client.  */
+/* Asynchronous I/O support.  SIGIO must be unblocked when waiting,
+   in order to accept Control-C from the client, and must be blocked
+   when talking to the client.  */
 
 static void
-unblock_async_io (void)
+block_unblock_async_io (int block)
 {
 #ifndef USE_WIN32API
   sigset_t sigio_set;
 
   sigemptyset (&sigio_set);
   sigaddset (&sigio_set, SIGIO);
-  sigprocmask (SIG_UNBLOCK, &sigio_set, NULL);
+  sigprocmask (block ? SIG_BLOCK : SIG_UNBLOCK, &sigio_set, NULL);
 #endif
 }
 
@@ -823,9 +828,8 @@ enable_async_io (void)
   if (async_io_enabled)
     return;
 
-#ifndef USE_WIN32API
-  signal (SIGIO, input_interrupt);
-#endif
+  block_unblock_async_io (0);
+
   async_io_enabled = 1;
 #ifdef __QNX__
   nto_comctrl (1);
@@ -839,9 +843,8 @@ disable_async_io (void)
   if (!async_io_enabled)
     return;
 
-#ifndef USE_WIN32API
-  signal (SIGIO, SIG_IGN);
-#endif
+  block_unblock_async_io (1);
+
   async_io_enabled = 0;
 #ifdef __QNX__
   nto_comctrl (0);
@@ -852,12 +855,14 @@ disable_async_io (void)
 void
 initialize_async_io (void)
 {
-  /* Make sure that async I/O starts disabled.  */
+  /* Make sure that async I/O starts blocked.  */
   async_io_enabled = 1;
   disable_async_io ();
 
-  /* Make sure the signal is unblocked.  */
-  unblock_async_io ();
+  /* Install the signal handler.  */
+#ifndef USE_WIN32API
+  signal (SIGIO, input_interrupt);
+#endif
 }
 
 /* Internal buffer used by readchar.