[PATCH v3 16/44] gdb, gdbserver, ze: add U stop reply

[Tankut Baris Aktemur <tankut.baris.aktemur@intel.com>]

From: Markus Metzger <markus.t.metzger@intel.com>

Add a new stop reply U for unavailable saying that we tried to stop a
process or thread but it would not respond and we cannot afford waiting.

This may occur when modeling threads as hardware threads on GPUs, where
threads that are currently idle cannot be interacted with.  We cannot
afford waiting for threads to become available again as that may require
submitting new work from the host process.  Or it may never happen for
some devices that simply are not used (anymore).

Reviewed-By: Eli Zaretskii <eliz@gnu.org>
---
 gdb/NEWS                  |  6 ++++++
 gdb/doc/gdb.texinfo       | 24 ++++++++++++++++++++++++
 gdb/remote.c              | 18 +++++++++++++++++-
 gdbserver/remote-utils.cc |  5 +++++
 gdbserver/server.cc       | 28 ++++++++++++++++++++++++++++
 5 files changed, 80 insertions(+), 1 deletion(-)

diff --git a/gdb/NEWS b/gdb/NEWS
index e95550496c4190f7032e917329ce497844a79e67..e281347eac138fd8f7c559a4cfed389b5b61e92b 100644
--- a/gdb/NEWS
+++ b/gdb/NEWS
@@ -209,6 +209,12 @@ vAck:in-memory-library
   after the initial processing by GDB such as loading symbols and placing
   breakpoints.
 
+U stop reply
+
+  Indicates that threads are currently unavailable.  We tried stopping them but
+  they did not respond.  The remote stub reports support for this stop reply to
+  GDB's qSupported query.
+
 * Changed remote packets
 
 qXfer:threads:read
diff --git a/gdb/doc/gdb.texinfo b/gdb/doc/gdb.texinfo
index faa93177e0e9f0a6b83ec9dda1031276ae1c114d..634675242bd4ff72b6742597133e7ad28d6768da 100644
--- a/gdb/doc/gdb.texinfo
+++ b/gdb/doc/gdb.texinfo
@@ -24882,6 +24882,10 @@ future connections is shown.  The available settings are:
 @tab @code{no resumed thread left stop reply}
 @tab Tracking thread lifetime.
 
+@item @code{unavailable-stop-reply}
+@tab @code{thread unavailable stop reply}
+@tab Tracking thread lifetime.
+
 @item @code{qXfer:libraries:read:in-memory-library}
 @tab @code{in-memory-library library elements}
 @tab Support for in-memory libraries.
@@ -44149,6 +44153,17 @@ reply packet from the target.  The latest @samp{C}, @samp{c}, @samp{S}
 or @samp{s} action is expected to be continued.  @xref{File-I/O Remote
 Protocol Extension}, for more details.
 
+@item U @var{thread-id}
+The program is currently unavailable.  The remote target tried to stop
+it but it would not respond.  The thread designator @var{thread-id}
+has the format and interpretation described in @ref{thread-id syntax}.
+
+This packet should not be sent by default; older @value{GDBN} versions
+did not support it.  @value{GDBN} requests it, by supplying an
+appropriate @samp{qSupported} feature (@pxref{qSupported}).  The
+remote stub must also supply the appropriate @samp{qSupported} feature
+indicating support.
+
 @end table
 
 @node General Query Packets
@@ -45378,6 +45393,11 @@ These are the currently defined stub features and their properties:
 @tab @samp{-}
 @tab No
 
+@item @samp{unavailable}
+@tab No
+@tab @samp{-}
+@tab No
+
 @end multitable
 
 These are the currently defined stub features, in more detail:
@@ -45627,6 +45647,10 @@ if it sent the @samp{error-message} feature.
 
 @item binary-upload
 The remote stub supports the @samp{x} packet (@pxref{x packet}).
+
+@item unavailable
+The remote stub reports the @samp{U} stop reply.
+
 @end table
 
 @item qSymbol::
diff --git a/gdb/remote.c b/gdb/remote.c
index b0e70e1517d6022ca7aba3b63ec34ddf90c85b7b..461bbfb783019e433a3a0378b3162444edc30dce 100644
--- a/gdb/remote.c
+++ b/gdb/remote.c
@@ -407,6 +407,9 @@ enum {
      errors, and so they should not need to check for this feature.  */
   PACKET_accept_error_message,
 
+  /* Support TARGET_WAITKIND_UNAVAILABLE.  */
+  PACKET_unavailable,
+
   PACKET_MAX
 };
 
@@ -5881,6 +5884,8 @@ static const struct protocol_feature remote_protocol_features[] = {
     PACKET_vAck_library },
   { "vAck:in-memory-library", PACKET_DISABLE, remote_supported_packet,
     PACKET_vAck_in_memory_library },
+  { "unavailable", PACKET_DISABLE, remote_supported_packet,
+    PACKET_unavailable },
 };
 
 static char *remote_support_xml;
@@ -5992,6 +5997,10 @@ remote_target::remote_query_supported ()
 	  != AUTO_BOOLEAN_FALSE)
 	remote_query_supported_append (&q, "memory-tagging+");
 
+      if (m_features.packet_set_cmd_state (PACKET_unavailable)
+	  != AUTO_BOOLEAN_FALSE)
+	remote_query_supported_append (&q, "unavailable+");
+
       remote_query_supported_append
 	(&q, "qXfer:libraries:read:in-memory-library+");
 
@@ -8377,6 +8386,10 @@ Packet: '%s'\n"),
       event->ws.set_no_resumed ();
       event->ptid = minus_one_ptid;
       break;
+    case 'U':
+      event->ws.set_unavailable ();
+      event->ptid = read_ptid (&buf[1], NULL);
+      break;
     }
 }
 
@@ -8790,7 +8803,7 @@ remote_target::wait_as (ptid_t ptid, target_waitstatus *status,
 	     again.  Keep waiting for events.  */
 	  rs->waiting_for_stop_reply = 1;
 	  break;
-	case 'N': case 'T': case 'S': case 'X': case 'W': case 'w':
+	case 'N': case 'T': case 'S': case 'X': case 'W': case 'w': case 'U':
 	  {
 	    /* There is a stop reply to handle.  */
 	    rs->waiting_for_stop_reply = 0;
@@ -16661,6 +16674,9 @@ Show the maximum size of the address (in bits) in a memory packet."), NULL,
   add_packet_config_cmd (PACKET_accept_error_message,
 			 "error-message", "error-message", 0);
 
+  add_packet_config_cmd (PACKET_unavailable,
+			 "U stop reply", "unavailable-stop-reply", 0);
+
   /* Assert that we've registered "set remote foo-packet" commands
      for all packet configs.  */
   {
diff --git a/gdbserver/remote-utils.cc b/gdbserver/remote-utils.cc
index 15f073dd6bece9225e03c4a0ab47b17f64ca3b72..6b4d15763afc8c31ecf05b902319b0a2c1427aa3 100644
--- a/gdbserver/remote-utils.cc
+++ b/gdbserver/remote-utils.cc
@@ -1287,6 +1287,11 @@ prepare_resume_reply (char *buf, ptid_t ptid, const target_waitstatus &status)
     case TARGET_WAITKIND_NO_RESUMED:
       sprintf (buf, "N");
       break;
+    case TARGET_WAITKIND_UNAVAILABLE:
+      sprintf (buf, "U");
+      buf += strlen (buf);
+      buf = write_ptid (buf, ptid);
+      break;
     default:
       error ("unhandled waitkind");
       break;
diff --git a/gdbserver/server.cc b/gdbserver/server.cc
index 1993a56fa78dc4b6dcd70beb0c1becddf34ff933..5fd804750bc878e36b4b825edad244c88d1b0253 100644
--- a/gdbserver/server.cc
+++ b/gdbserver/server.cc
@@ -88,6 +88,9 @@ bool run_once;
 /* Whether to report TARGET_WAITKIND_NO_RESUMED events.  */
 static bool report_no_resumed;
 
+/* Whether to report TARGET_WAITKIND_UNAVAILABLE events.  */
+static bool report_unavailable;
+
 /* The event loop checks this to decide whether to continue accepting
    events.  */
 static bool keep_processing_events = true;
@@ -2884,6 +2887,12 @@ handle_query (char *own_buf, int packet_len, int *new_packet_len_p)
 		}
 	      else if (feature == "error-message+")
 		cs.error_message_supported = true;
+	      else if (feature == "unavailable+")
+		{
+		  /* GDB supports and wants TARGET_WAITKIND_UNAVAILABLE
+		     events.  */
+		  report_unavailable = true;
+		}
 	      else if (feature == "qXfer:libraries:read:in-memory-library+")
 		cs.in_memory_library_supported = true;
 	      else if (feature == "vAck:library+")
@@ -3545,6 +3554,16 @@ resume (struct thread_resume *actions, size_t num_actions)
 	  return;
 	}
 
+      if (cs.last_status.kind () == TARGET_WAITKIND_UNAVAILABLE
+	  && !report_unavailable)
+	{
+	  /* The client does not support this stop reply.  At least
+	     return error.  */
+	  sprintf (cs.own_buf, "E.Unavailable.");
+	  disable_async_io ();
+	  return;
+	}
+
       if (cs.last_status.kind () != TARGET_WAITKIND_EXITED
 	  && cs.last_status.kind () != TARGET_WAITKIND_SIGNALLED
 	  && cs.last_status.kind () != TARGET_WAITKIND_THREAD_EXITED
@@ -5283,6 +5302,15 @@ handle_target_event (int err, gdb_client_data client_data)
       if (gdb_connected () && report_no_resumed)
 	push_stop_notification (null_ptid, cs.last_status);
     }
+  else if (cs.last_status.kind () == TARGET_WAITKIND_UNAVAILABLE)
+    {
+      /* Update the thread state but otherwise silently ignore this.
+
+	 We do need to report thread unavailability on resume or stop
+	 requests, but not as async target events.  */
+      if (current_thread != nullptr)
+	current_thread->last_status = cs.last_status;
+    }
   else if (cs.last_status.kind () != TARGET_WAITKIND_IGNORE)
     {
       int pid = cs.last_ptid.pid ();

-- 
2.34.1

Intel Deutschland GmbH
Registered Address: Am Campeon 10, 85579 Neubiberg, Germany
Tel: +49 89 99 8853-0, www.intel.de
Managing Directors: Sean Fennelly, Jeffrey Schneiderman, Tiffany Doon Silva
Chairperson of the Supervisory Board: Nicole Lau
Registered Office: Munich
Commercial Register: Amtsgericht Muenchen HRB 186928