gdb/remote-notif.c

   1 /* Remote notification in GDB protocol
   2
   3    Copyright (C) 1988-2020 Free Software Foundation, Inc.
   4
   5    This file is part of GDB.
   6
   7    This program is free software; you can redistribute it and/or modify
   8    it under the terms of the GNU General Public License as published by
   9    the Free Software Foundation; either version 3 of the License, or
  10    (at your option) any later version.
  11
  12    This program is distributed in the hope that it will be useful,
  13    but WITHOUT ANY WARRANTY; without even the implied warranty of
  14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15    GNU General Public License for more details.
  16
  17    You should have received a copy of the GNU General Public License
  18    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
  19
  20 /* Remote async notification is sent from remote target over RSP.
  21    Each type of notification is represented by an object of
  22    'struct notif', which has a field 'pending_reply'.  It is not
  23    NULL when GDB receives a notification from GDBserver, but hasn't
  24    acknowledge yet.  Before GDB acknowledges the notification,
  25    GDBserver shouldn't send notification again (see the header comments
  26    in gdbserver/notif.c).
  27
  28    Notifications are processed in an almost-unified approach for both
  29    all-stop mode and non-stop mode, except the timing to process them.
  30    In non-stop mode, notifications are processed in
  31    remote_async_get_pending_events_handler, while in all-stop mode,
  32    they are processed in remote_resume.  */
  33
  34 #include "defs.h"
  35 #include "remote.h"
  36 #include "remote-notif.h"
  37 #include "observable.h"
  38 #include "gdbsupport/event-loop.h"
  39 #include "target.h"
  40 #include "inferior.h"
  41 #include "infrun.h"
  42 #include "gdbcmd.h"
  43 #include "async-event.h"
  44
  45 bool notif_debug = false;
  46
  47 /* Supported clients of notifications.  */
  48
  49 static struct notif_client *notifs[] =
  50 {
  51   &notif_client_stop,
  52 };
  53
  54 gdb_static_assert (ARRAY_SIZE (notifs) == REMOTE_NOTIF_LAST);
  55
  56 /* Parse the BUF for the expected notification NC, and send packet to
  57    acknowledge.  */
  58
  59 void
  60 remote_notif_ack (remote_target *remote,
  61                   struct notif_client *nc, const char *buf)
  62 {
  63   notif_event_up event = nc->alloc_event ();
  64
  65   if (notif_debug)
  66     fprintf_unfiltered (gdb_stdlog, "notif: ack '%s'\n",
  67                         nc->ack_command);
  68
  69   nc->parse (remote, nc, buf, event.get ());
  70   nc->ack (remote, nc, buf, event.release ());
  71 }
  72
  73 /* Parse the BUF for the expected notification NC.  */
  74
  75 struct notif_event *
  76 remote_notif_parse (remote_target *remote,
  77                     struct notif_client *nc, const char *buf)
  78 {
  79   notif_event_up event = nc->alloc_event ();
  80
  81   if (notif_debug)
  82     fprintf_unfiltered (gdb_stdlog, "notif: parse '%s'\n", nc->name);
  83
  84   nc->parse (remote, nc, buf, event.get ());
  85
  86   return event.release ();
  87 }
  88
  89 /* Process notifications in STATE's notification queue one by one.
  90    EXCEPT is not expected in the queue.  */
  91
  92 void
  93 remote_notif_process (struct remote_notif_state *state,
  94                       struct notif_client *except)
  95 {
  96   while (!state->notif_queue.empty ())
  97     {
  98       struct notif_client *nc = state->notif_queue.front ();
  99       state->notif_queue.pop_front ();
 100
 101       gdb_assert (nc != except);
 102
 103       if (nc->can_get_pending_events (state->remote, nc))
 104         remote_notif_get_pending_events (state->remote, nc);
 105     }
 106 }
 107
 108 static void
 109 remote_async_get_pending_events_handler (gdb_client_data data)
 110 {
 111   gdb_assert (target_is_non_stop_p ());
 112   remote_notif_process ((struct remote_notif_state *) data, NULL);
 113 }
 114
 115 /* Remote notification handler.  Parse BUF, queue notification and
 116    update STATE.  */
 117
 118 void
 119 handle_notification (struct remote_notif_state *state, const char *buf)
 120 {
 121   struct notif_client *nc;
 122   size_t i;
 123
 124   for (i = 0; i < ARRAY_SIZE (notifs); i++)
 125     {
 126       const char *name = notifs[i]->name;
 127
 128       if (startswith (buf, name)
 129           && buf[strlen (name)] == ':')
 130         break;
 131     }
 132
 133   /* We ignore notifications we don't recognize, for compatibility
 134      with newer stubs.  */
 135   if (i == ARRAY_SIZE (notifs))
 136     return;
 137
 138   nc =  notifs[i];
 139
 140   if (state->pending_event[nc->id] != NULL)
 141     {
 142       /* We've already parsed the in-flight reply, but the stub for some
 143          reason thought we didn't, possibly due to timeout on its side.
 144          Just ignore it.  */
 145       if (notif_debug)
 146         fprintf_unfiltered (gdb_stdlog,
 147                             "notif: ignoring resent notification\n");
 148     }
 149   else
 150     {
 151       struct notif_event *event
 152         = remote_notif_parse (state->remote, nc, buf + strlen (nc->name) + 1);
 153
 154       /* Be careful to only set it after parsing, since an error
 155          may be thrown then.  */
 156       state->pending_event[nc->id] = event;
 157
 158       /* Notify the event loop there's a stop reply to acknowledge
 159          and that there may be more events to fetch.  */
 160       state->notif_queue.push_back (nc);
 161       if (target_is_non_stop_p ())
 162         {
 163           /* In non-stop, We mark REMOTE_ASYNC_GET_PENDING_EVENTS_TOKEN
 164              in order to go on what we were doing and postpone
 165              querying notification events to some point safe to do so.
 166              See details in the function comment of
 167              remote.c:remote_notif_get_pending_events.
 168
 169              In all-stop, GDB may be blocked to wait for the reply, we
 170              shouldn't return to event loop until the expected reply
 171              arrives.  For example:
 172
 173              1.1) --> vCont;c
 174                GDB expects getting stop reply 'T05 thread:2'.
 175              1.2) <-- %Notif
 176                <GDB marks the REMOTE_ASYNC_GET_PENDING_EVENTS_TOKEN>
 177
 178              After step #1.2, we return to the event loop, which
 179              notices there is a new event on the
 180              REMOTE_ASYNC_GET_PENDING_EVENTS_TOKEN and calls the
 181              handler, which will send 'vNotif' packet.
 182              1.3) --> vNotif
 183              It is not safe to start a new sequence, because target
 184              is still running and GDB is expecting the stop reply
 185              from stub.
 186
 187              To solve this, whenever we parse a notification
 188              successfully, we don't mark the
 189              REMOTE_ASYNC_GET_PENDING_EVENTS_TOKEN and let GDB blocked
 190              there as before to get the sequence done.
 191
 192              2.1) --> vCont;c
 193                GDB expects getting stop reply 'T05 thread:2'
 194              2.2) <-- %Notif
 195                <Don't mark the REMOTE_ASYNC_GET_PENDING_EVENTS_TOKEN>
 196              2.3) <-- T05 thread:2
 197
 198              These pending notifications can be processed later.  */
 199           mark_async_event_handler (state->get_pending_events_token);
 200         }
 201
 202       if (notif_debug)
 203         fprintf_unfiltered (gdb_stdlog,
 204                             "notif: Notification '%s' captured\n",
 205                             nc->name);
 206     }
 207 }
 208
 209 /* Return an allocated remote_notif_state.  */
 210
 211 struct remote_notif_state *
 212 remote_notif_state_allocate (remote_target *remote)
 213 {
 214   struct remote_notif_state *notif_state = new struct remote_notif_state;
 215
 216   notif_state->remote = remote;
 217
 218   /* Register async_event_handler for notification.  */
 219
 220   notif_state->get_pending_events_token
 221     = create_async_event_handler (remote_async_get_pending_events_handler,
 222                                   notif_state);
 223
 224   return notif_state;
 225 }
 226
 227 /* Free STATE and its fields.  */
 228
 229 remote_notif_state::~remote_notif_state ()
 230 {
 231   int i;
 232
 233   /* Unregister async_event_handler for notification.  */
 234   if (get_pending_events_token != NULL)
 235     delete_async_event_handler (&get_pending_events_token);
 236
 237   for (i = 0; i < REMOTE_NOTIF_LAST; i++)
 238     delete pending_event[i];
 239 }
 240
 241 void _initialize_notif ();
 242 void
 243 _initialize_notif ()
 244 {
 245   add_setshow_boolean_cmd ("notification", no_class, &notif_debug,
 246                            _("\
 247 Set debugging of async remote notification."), _("\
 248 Show debugging of async remote notification."), _("\
 249 When non-zero, debugging output about async remote notifications"
 250 " is enabled."),
 251                            NULL,
 252                            NULL,
 253                            &setdebuglist, &showdebuglist);
 254 }