Re: [RFC] Autoload-breakpoints new version [3/9] notification async

[Hui Zhu <teawater@gmail.com>]

[-- Attachment #1: Type: text/plain, Size: 1607 bytes --]

On Tue, Aug 14, 2012 at 8:01 PM, Hui Zhu <teawater@gmail.com> wrote:
> On Mon, Aug 13, 2012 at 10:24 AM, Yao Qi <yao@codesourcery.com> wrote:
>> On 08/11/2012 11:19 PM, Hui Zhu wrote:
>>>>
>>>> >
>>>> >I applied patch 1/9 and 3/9, and get following regressions in gdbserver
>>>> > with
>>>> >async mode on.
>>>> >
>>>> >   FAIL: gdb.mi/mi-nonstop-exit.exp: finished exec continue (unknown
>>>> > output
>>>> >after running)
>>>> >   FAIL: gdb.mi/mi-nonstop-exit.exp: finished exec continue (2) (unknown
>>>> > output
>>>> >after running)
>>>> >   FAIL: gdb.mi/mi-nsmoribund.exp: resume all, waiting for program exit
>>>> >(timeout)
>>>
>>> My part is OK, Could you tell me how do you do the test?
>>>
>>
>> In gdb build dir, add the following line into testsuite/site.exp
>>
>>   set GDBFLAGS "-ex \"set target-async on\""
>>
>> make check RUNTESTFLAGS="--target_board=native-gdbserver"
>>
>> or you can set GDBFLAGS in your own board file other than testuite/site.exp.
>>
>> --
>> Yao
>
> Hi guys,
>
> I found this issue is because notification "Stop:" cannot be handled
> in async handler.
> What I thought is push it back a buffer and let GDB  handle it later
> that GDB in right status to handle it.
>
> I didn't have other good idea on this issue is because I cannot
> reproduce it in command line.
>
> Do you have some comments on this issue?
>
> Thanks,
> Hui

Hi,

I done a new version to handle this issue.
Because readchar will throw error and pop_target directly in remote.c.
So I change it use another way to handle it.  Not sure it is good or
not.  But it make test can be passed.

Thanks,
Hui

[-- Attachment #2: notification_async.txt --]
[-- Type: text/plain, Size: 6680 bytes --]

---

---
 remote.c |  108 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++------
 1 file changed, 98 insertions(+), 10 deletions(-)

--- a/remote.c
+++ b/remote.c
@@ -224,6 +224,11 @@ static void remote_query_supported (void
 
 static void remote_check_symbols (struct objfile *objfile);
 
+static void (*async_client_callback) (enum inferior_event_type event_type,
+				      void *context);
+static void *async_client_context;
+static serial_event_ftype remote_async_serial_handler;
+
 void _initialize_remote (void);
 
 struct stop_reply;
@@ -1297,6 +1302,7 @@ enum {
   PACKET_QDisableRandomization,
   PACKET_QAgent,
   PACKET_AutoloadBreakpoints,
+  PACKET_NotificationAsync,
   PACKET_MAX
 };
 
@@ -3998,6 +4004,8 @@ static struct protocol_feature remote_pr
     remote_string_tracing_feature, -1 },
   { "AutoloadBreakpoints", PACKET_DISABLE, remote_supported_packet,
     PACKET_AutoloadBreakpoints },
+  { "NotificationAsync", PACKET_DISABLE, remote_supported_packet,
+    PACKET_NotificationAsync },
 };
 
 static char *remote_support_xml;
@@ -4355,6 +4363,10 @@ remote_open_1 (char *name, int from_tty,
 
   if (target_async_permitted)
     wait_forever_enabled_p = 1;
+
+  if (remote_protocol_packets[PACKET_NotificationAsync].support
+	  != PACKET_DISABLE)
+    serial_async (remote_desc, remote_async_serial_handler, NULL);
 }
 
 /* This takes a program previously attached to and detaches it.  After
@@ -6980,11 +6992,20 @@ remote_files_info (struct target_ops *ig
 
 /* Read a single character from the remote end.  */
 
+static int readchar_buffer_ch = -1;
+
 static int
 readchar (int timeout)
 {
   int ch;
 
+  if (readchar_buffer_ch != -1)
+    {
+      ch = readchar_buffer_ch;
+      readchar_buffer_ch = -1;
+      return ch;
+    }
+
   ch = serial_readchar (remote_desc, timeout);
 
   if (ch >= 0)
@@ -6993,8 +7014,12 @@ readchar (int timeout)
   switch ((enum serial_rc) ch)
     {
     case SERIAL_EOF:
-      pop_target ();
-      error (_("Remote connection closed"));
+      if (timeout)
+        {
+	  pop_target ();
+	  error (_("Remote connection closed"));
+	}
+      break;
       /* no return */
     case SERIAL_ERROR:
       pop_target ();
@@ -7007,6 +7032,17 @@ readchar (int timeout)
   return ch;
 }
 
+/* When the function that call the readchar got a char is not for it
+   and other function need this char，call this function to put
+   this char back.  Then when other function call readchar, it will
+   got this char first. */
+
+static void
+readchar_buffer_put (int ch)
+{
+  readchar_buffer_ch = ch;
+}
+
 /* Send the command in *BUF to the remote machine, and read the reply
    into *BUF.  Report an error if we get an error reply.  Resize
    *BUF using xrealloc if necessary to hold the result, and update
@@ -7507,7 +7543,11 @@ getpkt_or_notif_sane_1 (char **buf, long
 	     show up within remote_timeout intervals.  */
 	  do
 	    c = readchar (timeout);
-	  while (c != SERIAL_TIMEOUT && c != '$' && c != '%');
+	  while (c != SERIAL_TIMEOUT && c != SERIAL_EOF && c != '$'
+		 && c != '%');
+
+	  if (c == SERIAL_EOF)
+	    return -1;
 
 	  if (c == SERIAL_TIMEOUT)
 	    {
@@ -11207,25 +11247,72 @@ remote_is_async_p (void)
     /* We only enable async when the user specifically asks for it.  */
     return 0;
 
+  if (remote_protocol_packets[PACKET_NotificationAsync].support
+	  != PACKET_DISABLE)
+    return async_client_callback != NULL;
+
   /* We're async whenever the serial device is.  */
   return serial_is_async_p (remote_desc);
 }
 
+static int
+remote_is_notificationasync (void)
+{
+  int c = serial_readchar (remote_desc, 0);
+
+  if (c == '%')
+    return 1;
+
+  if (c >= 0)
+    readchar_buffer_put (c);
+  return 0;
+}
+
 /* Pass the SERIAL event on and up to the client.  One day this code
    will be able to delay notifying the client of an event until the
    point where an entire packet has been received.  */
 
-static void (*async_client_callback) (enum inferior_event_type event_type,
-				      void *context);
-static void *async_client_context;
-static serial_event_ftype remote_async_serial_handler;
-
 static void
 remote_async_serial_handler (struct serial *scb, void *context)
 {
-  /* Don't propogate error information up to the client.  Instead let
-     the client find out about the error by querying the target.  */
-  async_client_callback (INF_REG_EVENT, async_client_context);
+  /* Check if this is ReportAsync.  */
+  if (remote_is_notificationasync ())
+    {
+      int val;
+      struct remote_state *rs = get_remote_state ();
+
+      val = read_frame (&rs->buf, &rs->buf_size);
+      if (val >= 0)
+	{
+	  if (remote_debug)
+	    {
+	      struct cleanup *old_chain;
+	      char *str;
+
+	      str = escape_buffer (rs->buf, val);
+	      old_chain = make_cleanup (xfree, str);
+	      fprintf_unfiltered (gdb_stdlog, "  Notification received: %s\n",
+				  str);
+	      do_cleanups (old_chain);
+	    }
+	  handle_notification (rs->buf, val);
+	}
+      else
+	{
+	  if (remote_debug)
+	    {
+	      fprintf_unfiltered (gdb_stdlog, "putpkt: Junk: ");
+	      fprintf_unfiltered (gdb_stdlog, "%%%s", rs->buf);
+	    }
+	}
+    }
+  else
+    {
+      /* Don't propogate error information up to the client.  Instead let
+         the client find out about the error by querying the target.  */
+      if (async_client_callback)
+	async_client_callback (INF_REG_EVENT, async_client_context);
+    }
 }
 
 static void
@@ -11246,12 +11333,19 @@ remote_async (void (*callback) (enum inf
 {
   if (callback != NULL)
     {
-      serial_async (remote_desc, remote_async_serial_handler, NULL);
+      if (remote_protocol_packets[PACKET_NotificationAsync].support
+	      == PACKET_DISABLE)
+        serial_async (remote_desc, remote_async_serial_handler, NULL);
       async_client_callback = callback;
       async_client_context = context;
     }
   else
-    serial_async (remote_desc, NULL, NULL);
+    {
+      if (remote_protocol_packets[PACKET_NotificationAsync].support
+	      == PACKET_DISABLE)
+	serial_async (remote_desc, NULL, NULL);
+      async_client_callback = NULL;
+    }
 }
 
 static void
@@ -11769,6 +11863,9 @@ Show the maximum size of the address (in
   add_packet_config_cmd (&remote_protocol_packets[PACKET_AutoloadBreakpoints],
 			 "AutoloadBreakpoints", "autoload-breakpoints", 0);
 
+  add_packet_config_cmd (&remote_protocol_packets[PACKET_NotificationAsync],
+			 "NotificationAsync", "notification-async", 0);
+
   /* Keep the old ``set remote Z-packet ...'' working.  Each individual
      Z sub-packet has its own set and show commands, but users may
      have sets to this variable in their .gdbinit files (or in their