1 /* Remote notification in GDB protocol 2 3 Copyright (C) 1988-2023 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 ¬if_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 gdb_printf (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 gdb_printf (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 remote_notif_state *notif_state = (remote_notif_state *) data; 112 clear_async_event_handler (notif_state->get_pending_events_token); 113 gdb_assert (remote_target_is_non_stop_p (notif_state->remote)); 114 remote_notif_process (notif_state, NULL); 115 } 116 117 /* Remote notification handler. Parse BUF, queue notification and 118 update STATE. */ 119 120 void 121 handle_notification (struct remote_notif_state *state, const char *buf) 122 { 123 struct notif_client *nc; 124 size_t i; 125 126 for (i = 0; i < ARRAY_SIZE (notifs); i++) 127 { 128 const char *name = notifs[i]->name; 129 130 if (startswith (buf, name) 131 && buf[strlen (name)] == ':') 132 break; 133 } 134 135 /* We ignore notifications we don't recognize, for compatibility 136 with newer stubs. */ 137 if (i == ARRAY_SIZE (notifs)) 138 return; 139 140 nc = notifs[i]; 141 142 if (state->pending_event[nc->id] != NULL) 143 { 144 /* We've already parsed the in-flight reply, but the stub for some 145 reason thought we didn't, possibly due to timeout on its side. 146 Just ignore it. */ 147 if (notif_debug) 148 gdb_printf (gdb_stdlog, 149 "notif: ignoring resent notification\n"); 150 } 151 else 152 { 153 struct notif_event *event 154 = remote_notif_parse (state->remote, nc, buf + strlen (nc->name) + 1); 155 156 /* Be careful to only set it after parsing, since an error 157 may be thrown then. */ 158 state->pending_event[nc->id] = event; 159 160 /* Notify the event loop there's a stop reply to acknowledge 161 and that there may be more events to fetch. */ 162 state->notif_queue.push_back (nc); 163 if (target_is_non_stop_p ()) 164 { 165 /* In non-stop, We mark REMOTE_ASYNC_GET_PENDING_EVENTS_TOKEN 166 in order to go on what we were doing and postpone 167 querying notification events to some point safe to do so. 168 See details in the function comment of 169 remote.c:remote_notif_get_pending_events. 170 171 In all-stop, GDB may be blocked to wait for the reply, we 172 shouldn't return to event loop until the expected reply 173 arrives. For example: 174 175 1.1) --> vCont;c 176 GDB expects getting stop reply 'T05 thread:2'. 177 1.2) <-- %Notif 178 <GDB marks the REMOTE_ASYNC_GET_PENDING_EVENTS_TOKEN> 179 180 After step #1.2, we return to the event loop, which 181 notices there is a new event on the 182 REMOTE_ASYNC_GET_PENDING_EVENTS_TOKEN and calls the 183 handler, which will send 'vNotif' packet. 184 1.3) --> vNotif 185 It is not safe to start a new sequence, because target 186 is still running and GDB is expecting the stop reply 187 from stub. 188 189 To solve this, whenever we parse a notification 190 successfully, we don't mark the 191 REMOTE_ASYNC_GET_PENDING_EVENTS_TOKEN and let GDB blocked 192 there as before to get the sequence done. 193 194 2.1) --> vCont;c 195 GDB expects getting stop reply 'T05 thread:2' 196 2.2) <-- %Notif 197 <Don't mark the REMOTE_ASYNC_GET_PENDING_EVENTS_TOKEN> 198 2.3) <-- T05 thread:2 199 200 These pending notifications can be processed later. */ 201 mark_async_event_handler (state->get_pending_events_token); 202 } 203 204 if (notif_debug) 205 gdb_printf (gdb_stdlog, 206 "notif: Notification '%s' captured\n", 207 nc->name); 208 } 209 } 210 211 /* Return an allocated remote_notif_state. */ 212 213 struct remote_notif_state * 214 remote_notif_state_allocate (remote_target *remote) 215 { 216 struct remote_notif_state *notif_state = new struct remote_notif_state; 217 218 notif_state->remote = remote; 219 220 /* Register async_event_handler for notification. */ 221 222 notif_state->get_pending_events_token 223 = create_async_event_handler (remote_async_get_pending_events_handler, 224 notif_state, "remote-notif"); 225 226 return notif_state; 227 } 228 229 /* Free STATE and its fields. */ 230 231 remote_notif_state::~remote_notif_state () 232 { 233 int i; 234 235 /* Unregister async_event_handler for notification. */ 236 if (get_pending_events_token != NULL) 237 delete_async_event_handler (&get_pending_events_token); 238 239 for (i = 0; i < REMOTE_NOTIF_LAST; i++) 240 delete pending_event[i]; 241 } 242 243 void _initialize_notif (); 244 void 245 _initialize_notif () 246 { 247 add_setshow_boolean_cmd ("notification", no_class, ¬if_debug, 248 _("\ 249 Set debugging of async remote notification."), _("\ 250 Show debugging of async remote notification."), _("\ 251 When non-zero, debugging output about async remote notifications" 252 " is enabled."), 253 NULL, 254 NULL, 255 &setdebuglist, &showdebuglist); 256 } 257