1 /* Remote notification in GDB protocol
3 Copyright (C) 1988-2020 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 "gdbsupport/event-loop.h"
43 #include "async-event.h"
45 bool notif_debug
= false;
47 /* Supported clients of notifications. */
49 static struct notif_client
*notifs
[] =
54 gdb_static_assert (ARRAY_SIZE (notifs
) == REMOTE_NOTIF_LAST
);
56 /* Parse the BUF for the expected notification NC, and send packet to
60 remote_notif_ack (remote_target
*remote
,
61 struct notif_client
*nc
, const char *buf
)
63 notif_event_up event
= nc
->alloc_event ();
66 fprintf_unfiltered (gdb_stdlog
, "notif: ack '%s'\n",
69 nc
->parse (remote
, nc
, buf
, event
.get ());
70 nc
->ack (remote
, nc
, buf
, event
.release ());
73 /* Parse the BUF for the expected notification NC. */
76 remote_notif_parse (remote_target
*remote
,
77 struct notif_client
*nc
, const char *buf
)
79 notif_event_up event
= nc
->alloc_event ();
82 fprintf_unfiltered (gdb_stdlog
, "notif: parse '%s'\n", nc
->name
);
84 nc
->parse (remote
, nc
, buf
, event
.get ());
86 return event
.release ();
89 /* Process notifications in STATE's notification queue one by one.
90 EXCEPT is not expected in the queue. */
93 remote_notif_process (struct remote_notif_state
*state
,
94 struct notif_client
*except
)
96 while (!state
->notif_queue
.empty ())
98 struct notif_client
*nc
= state
->notif_queue
.front ();
99 state
->notif_queue
.pop_front ();
101 gdb_assert (nc
!= except
);
103 if (nc
->can_get_pending_events (state
->remote
, nc
))
104 remote_notif_get_pending_events (state
->remote
, nc
);
109 remote_async_get_pending_events_handler (gdb_client_data data
)
111 gdb_assert (target_is_non_stop_p ());
112 remote_notif_process ((struct remote_notif_state
*) data
, NULL
);
115 /* Remote notification handler. Parse BUF, queue notification and
119 handle_notification (struct remote_notif_state
*state
, const char *buf
)
121 struct notif_client
*nc
;
124 for (i
= 0; i
< ARRAY_SIZE (notifs
); i
++)
126 const char *name
= notifs
[i
]->name
;
128 if (startswith (buf
, name
)
129 && buf
[strlen (name
)] == ':')
133 /* We ignore notifications we don't recognize, for compatibility
135 if (i
== ARRAY_SIZE (notifs
))
140 if (state
->pending_event
[nc
->id
] != NULL
)
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.
146 fprintf_unfiltered (gdb_stdlog
,
147 "notif: ignoring resent notification\n");
151 struct notif_event
*event
152 = remote_notif_parse (state
->remote
, nc
, buf
+ strlen (nc
->name
) + 1);
154 /* Be careful to only set it after parsing, since an error
155 may be thrown then. */
156 state
->pending_event
[nc
->id
] = event
;
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 ())
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.
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:
174 GDB expects getting stop reply 'T05 thread:2'.
176 <GDB marks the REMOTE_ASYNC_GET_PENDING_EVENTS_TOKEN>
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.
183 It is not safe to start a new sequence, because target
184 is still running and GDB is expecting the stop reply
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.
193 GDB expects getting stop reply 'T05 thread:2'
195 <Don't mark the REMOTE_ASYNC_GET_PENDING_EVENTS_TOKEN>
196 2.3) <-- T05 thread:2
198 These pending notifications can be processed later. */
199 mark_async_event_handler (state
->get_pending_events_token
);
203 fprintf_unfiltered (gdb_stdlog
,
204 "notif: Notification '%s' captured\n",
209 /* Return an allocated remote_notif_state. */
211 struct remote_notif_state
*
212 remote_notif_state_allocate (remote_target
*remote
)
214 struct remote_notif_state
*notif_state
= new struct remote_notif_state
;
216 notif_state
->remote
= remote
;
218 /* Register async_event_handler for notification. */
220 notif_state
->get_pending_events_token
221 = create_async_event_handler (remote_async_get_pending_events_handler
,
227 /* Free STATE and its fields. */
229 remote_notif_state::~remote_notif_state ()
233 /* Unregister async_event_handler for notification. */
234 if (get_pending_events_token
!= NULL
)
235 delete_async_event_handler (&get_pending_events_token
);
237 for (i
= 0; i
< REMOTE_NOTIF_LAST
; i
++)
238 delete pending_event
[i
];
241 void _initialize_notif ();
245 add_setshow_boolean_cmd ("notification", no_class
, ¬if_debug
,
247 Set debugging of async remote notification."), _("\
248 Show debugging of async remote notification."), _("\
249 When non-zero, debugging output about async remote notifications"
253 &setdebuglist
, &showdebuglist
);