1 /* Remote notification in GDB protocol
3 Copyright (C) 1988-2019 Free Software Foundation, Inc.
5 This file is part of GDB.
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.
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.
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/>. */
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).
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. */
36 #include "remote-notif.h"
37 #include "observable.h"
38 #include "event-loop.h"
46 /* Supported clients of notifications. */
48 static struct notif_client *notifs[] =
53 gdb_static_assert (ARRAY_SIZE (notifs) == REMOTE_NOTIF_LAST);
55 static void do_notif_event_xfree (void *arg);
57 /* Parse the BUF for the expected notification NC, and send packet to
61 remote_notif_ack (remote_target *remote,
62 struct notif_client *nc, char *buf)
64 struct notif_event *event = nc->alloc_event ();
65 struct cleanup *old_chain
66 = make_cleanup (do_notif_event_xfree, event);
69 fprintf_unfiltered (gdb_stdlog, "notif: ack '%s'\n",
72 nc->parse (remote, nc, buf, event);
73 nc->ack (remote, nc, buf, event);
75 discard_cleanups (old_chain);
78 /* Parse the BUF for the expected notification NC. */
81 remote_notif_parse (remote_target *remote,
82 struct notif_client *nc, char *buf)
84 struct notif_event *event = nc->alloc_event ();
85 struct cleanup *old_chain
86 = make_cleanup (do_notif_event_xfree, event);
89 fprintf_unfiltered (gdb_stdlog, "notif: parse '%s'\n", nc->name);
91 nc->parse (remote, nc, buf, event);
93 discard_cleanups (old_chain);
97 DEFINE_QUEUE_P (notif_client_p);
99 /* Process notifications in STATE's notification queue one by one.
100 EXCEPT is not expected in the queue. */
103 remote_notif_process (struct remote_notif_state *state,
104 struct notif_client *except)
106 while (!QUEUE_is_empty (notif_client_p, state->notif_queue))
108 struct notif_client *nc = QUEUE_deque (notif_client_p,
111 gdb_assert (nc != except);
113 if (nc->can_get_pending_events (state->remote, nc))
114 remote_notif_get_pending_events (state->remote, nc);
119 remote_async_get_pending_events_handler (gdb_client_data data)
121 gdb_assert (target_is_non_stop_p ());
122 remote_notif_process ((struct remote_notif_state *) data, NULL);
125 /* Remote notification handler. Parse BUF, queue notification and
129 handle_notification (struct remote_notif_state *state, char *buf)
131 struct notif_client *nc;
134 for (i = 0; i < ARRAY_SIZE (notifs); i++)
136 const char *name = notifs[i]->name;
138 if (startswith (buf, name)
139 && buf[strlen (name)] == ':')
143 /* We ignore notifications we don't recognize, for compatibility
145 if (i == ARRAY_SIZE (notifs))
150 if (state->pending_event[nc->id] != NULL)
152 /* We've already parsed the in-flight reply, but the stub for some
153 reason thought we didn't, possibly due to timeout on its side.
156 fprintf_unfiltered (gdb_stdlog,
157 "notif: ignoring resent notification\n");
161 struct notif_event *event
162 = remote_notif_parse (state->remote, nc, buf + strlen (nc->name) + 1);
164 /* Be careful to only set it after parsing, since an error
165 may be thrown then. */
166 state->pending_event[nc->id] = event;
168 /* Notify the event loop there's a stop reply to acknowledge
169 and that there may be more events to fetch. */
170 QUEUE_enque (notif_client_p, state->notif_queue, nc);
171 if (target_is_non_stop_p ())
173 /* In non-stop, We mark REMOTE_ASYNC_GET_PENDING_EVENTS_TOKEN
174 in order to go on what we were doing and postpone
175 querying notification events to some point safe to do so.
176 See details in the function comment of
177 remote.c:remote_notif_get_pending_events.
179 In all-stop, GDB may be blocked to wait for the reply, we
180 shouldn't return to event loop until the expected reply
181 arrives. For example:
184 GDB expects getting stop reply 'T05 thread:2'.
186 <GDB marks the REMOTE_ASYNC_GET_PENDING_EVENTS_TOKEN>
188 After step #1.2, we return to the event loop, which
189 notices there is a new event on the
190 REMOTE_ASYNC_GET_PENDING_EVENTS_TOKEN and calls the
191 handler, which will send 'vNotif' packet.
193 It is not safe to start a new sequence, because target
194 is still running and GDB is expecting the stop reply
197 To solve this, whenever we parse a notification
198 successfully, we don't mark the
199 REMOTE_ASYNC_GET_PENDING_EVENTS_TOKEN and let GDB blocked
200 there as before to get the sequence done.
203 GDB expects getting stop reply 'T05 thread:2'
205 <Don't mark the REMOTE_ASYNC_GET_PENDING_EVENTS_TOKEN>
206 2.3) <-- T05 thread:2
208 These pending notifications can be processed later. */
209 mark_async_event_handler (state->get_pending_events_token);
213 fprintf_unfiltered (gdb_stdlog,
214 "notif: Notification '%s' captured\n",
219 /* Invoke destructor of EVENT and xfree it. */
222 notif_event_xfree (struct notif_event *event)
224 if (event != NULL && event->dtr != NULL)
230 /* Cleanup wrapper. */
233 do_notif_event_xfree (void *arg)
235 notif_event_xfree ((struct notif_event *) arg);
238 /* Return an allocated remote_notif_state. */
240 struct remote_notif_state *
241 remote_notif_state_allocate (remote_target *remote)
243 struct remote_notif_state *notif_state = XCNEW (struct remote_notif_state);
245 notif_state->remote = remote;
247 notif_state->notif_queue = QUEUE_alloc (notif_client_p, NULL);
249 /* Register async_event_handler for notification. */
251 notif_state->get_pending_events_token
252 = create_async_event_handler (remote_async_get_pending_events_handler,
258 /* Free STATE and its fields. */
261 remote_notif_state_xfree (struct remote_notif_state *state)
265 QUEUE_free (notif_client_p, state->notif_queue);
267 /* Unregister async_event_handler for notification. */
268 if (state->get_pending_events_token != NULL)
269 delete_async_event_handler (&state->get_pending_events_token);
271 for (i = 0; i < REMOTE_NOTIF_LAST; i++)
272 notif_event_xfree (state->pending_event[i]);
278 _initialize_notif (void)
280 add_setshow_boolean_cmd ("notification", no_class, ¬if_debug,
282 Set debugging of async remote notification."), _("\
283 Show debugging of async remote notification."), _("\
284 When non-zero, debugging output about async remote notifications"
288 &setdebuglist, &showdebuglist);