1 /* Event loop machinery for the remote server for GDB.
2 Copyright (C) 1999, 2000, 2001, 2002, 2005, 2006, 2007, 2008, 2010
3 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 /* Based on src/gdb/event-loop.c. */
24 #include <sys/types.h>
41 typedef struct gdb_event gdb_event
;
42 typedef int (event_handler_func
) (int);
44 /* Tell create_file_handler what events we are interested in. */
46 #define GDB_READABLE (1<<1)
47 #define GDB_WRITABLE (1<<2)
48 #define GDB_EXCEPTION (1<<3)
50 /* Events are queued by calling async_queue_event and serviced later
51 on by do_one_event. An event can be, for instance, a file
52 descriptor becoming ready to be read. Servicing an event simply
53 means that the procedure PROC will be called. We have 2 queues,
54 one for file handlers that we listen to in the event loop, and one
55 for the file handlers+events that are ready. The procedure PROC
56 associated with each event is always the same (handle_file_event).
57 Its duty is to invoke the handler associated with the file
58 descriptor whose state change generated the event, plus doing other
63 /* Procedure to call to service this event. */
64 event_handler_func
*proc
;
66 /* File descriptor that is ready. */
69 /* Next in list of events or NULL. */
70 struct gdb_event
*next_event
;
73 /* Information about each file descriptor we register with the event
76 typedef struct file_handler
78 /* File descriptor. */
81 /* Events we want to monitor. */
84 /* Events that have been seen since the last time. */
87 /* Procedure to call when fd is ready. */
90 /* Argument to pass to proc. */
91 gdb_client_data client_data
;
93 /* Was an error detected on this fd? */
96 /* Next registered file descriptor. */
97 struct file_handler
*next_file
;
103 Events can be inserted at the front of the queue or at the end of
104 the queue. Events will be extracted from the queue for processing
105 starting from the head. Therefore, events inserted at the head of
106 the queue will be processed in a last in first out fashion, while
107 those inserted at the tail of the queue will be processed in a
108 first in first out manner. All the fields are NULL if the queue is
113 /* The first pending event. */
114 gdb_event
*first_event
;
116 /* The last pending event. */
117 gdb_event
*last_event
;
121 /* Gdb_notifier is just a list of file descriptors gdb is interested
122 in. These are the input file descriptor, and the target file
123 descriptor. Each of the elements in the gdb_notifier list is
124 basically a description of what kind of events gdb is interested
129 /* Ptr to head of file handler list. */
130 file_handler
*first_file_handler
;
132 /* Masks to be used in the next call to select. Bits are set in
133 response to calls to create_file_handler. */
134 fd_set check_masks
[3];
136 /* What file descriptors were found ready by select. */
137 fd_set ready_masks
[3];
139 /* Number of valid bits (highest fd value + 1). (for select) */
144 /* Insert an event object into the gdb event queue.
146 EVENT_PTR points to the event to be inserted into the queue. The
147 caller must allocate memory for the event. It is freed after the
148 event has ben handled. Events in the queue will be processed head
149 to tail, therefore, events will be processed first in first
153 async_queue_event (gdb_event
*event_ptr
)
155 /* The event will become the new last_event. */
157 event_ptr
->next_event
= NULL
;
158 if (event_queue
.first_event
== NULL
)
159 event_queue
.first_event
= event_ptr
;
161 event_queue
.last_event
->next_event
= event_ptr
;
162 event_queue
.last_event
= event_ptr
;
165 /* Process one event. If an event was processed, 1 is returned
166 otherwise 0 is returned. Scan the queue from head to tail,
167 processing therefore the high priority events first, by invoking
168 the associated event handler procedure. */
173 gdb_event
*event_ptr
, *prev_ptr
;
174 event_handler_func
*proc
;
177 /* Look in the event queue to find an event that is ready
180 for (event_ptr
= event_queue
.first_event
;
182 event_ptr
= event_ptr
->next_event
)
184 /* Call the handler for the event. */
186 proc
= event_ptr
->proc
;
189 /* Let's get rid of the event from the event queue. We need to
190 do this now because while processing the event, since the
191 proc function could end up jumping out to the caller of this
192 function. In that case, we would have on the event queue an
193 event which has been processed, but not deleted. */
195 if (event_queue
.first_event
== event_ptr
)
197 event_queue
.first_event
= event_ptr
->next_event
;
198 if (event_ptr
->next_event
== NULL
)
199 event_queue
.last_event
= NULL
;
203 prev_ptr
= event_queue
.first_event
;
204 while (prev_ptr
->next_event
!= event_ptr
)
205 prev_ptr
= prev_ptr
->next_event
;
207 prev_ptr
->next_event
= event_ptr
->next_event
;
208 if (event_ptr
->next_event
== NULL
)
209 event_queue
.last_event
= prev_ptr
;
213 /* Now call the procedure associated with the event. */
219 /* This is the case if there are no event on the event queue. */
223 /* Add a file handler/descriptor to the list of descriptors we are
224 interested in. FD is the file descriptor for the file/stream to be
225 listened to. MASK is a combination of READABLE, WRITABLE,
226 EXCEPTION. PROC is the procedure that will be called when an event
227 occurs for FD. CLIENT_DATA is the argument to pass to PROC. */
230 create_file_handler (int fd
, int mask
, handler_func
*proc
,
231 gdb_client_data client_data
)
233 file_handler
*file_ptr
;
235 /* Do we already have a file handler for this file? (We may be
236 changing its associated procedure). */
237 for (file_ptr
= gdb_notifier
.first_file_handler
;
239 file_ptr
= file_ptr
->next_file
)
240 if (file_ptr
->fd
== fd
)
243 /* It is a new file descriptor. Add it to the list. Otherwise,
244 just change the data associated with it. */
245 if (file_ptr
== NULL
)
247 file_ptr
= xmalloc (sizeof (*file_ptr
));
249 file_ptr
->ready_mask
= 0;
250 file_ptr
->next_file
= gdb_notifier
.first_file_handler
;
251 gdb_notifier
.first_file_handler
= file_ptr
;
253 if (mask
& GDB_READABLE
)
254 FD_SET (fd
, &gdb_notifier
.check_masks
[0]);
256 FD_CLR (fd
, &gdb_notifier
.check_masks
[0]);
258 if (mask
& GDB_WRITABLE
)
259 FD_SET (fd
, &gdb_notifier
.check_masks
[1]);
261 FD_CLR (fd
, &gdb_notifier
.check_masks
[1]);
263 if (mask
& GDB_EXCEPTION
)
264 FD_SET (fd
, &gdb_notifier
.check_masks
[2]);
266 FD_CLR (fd
, &gdb_notifier
.check_masks
[2]);
268 if (gdb_notifier
.num_fds
<= fd
)
269 gdb_notifier
.num_fds
= fd
+ 1;
272 file_ptr
->proc
= proc
;
273 file_ptr
->client_data
= client_data
;
274 file_ptr
->mask
= mask
;
277 /* Wrapper function for create_file_handler. */
280 add_file_handler (int fd
, handler_func
*proc
, gdb_client_data client_data
)
282 create_file_handler (fd
, GDB_READABLE
| GDB_EXCEPTION
, proc
, client_data
);
285 /* Remove the file descriptor FD from the list of monitored fd's:
286 i.e. we don't care anymore about events on the FD. */
289 delete_file_handler (int fd
)
291 file_handler
*file_ptr
, *prev_ptr
= NULL
;
294 /* Find the entry for the given file. */
296 for (file_ptr
= gdb_notifier
.first_file_handler
;
298 file_ptr
= file_ptr
->next_file
)
299 if (file_ptr
->fd
== fd
)
302 if (file_ptr
== NULL
)
305 if (file_ptr
->mask
& GDB_READABLE
)
306 FD_CLR (fd
, &gdb_notifier
.check_masks
[0]);
307 if (file_ptr
->mask
& GDB_WRITABLE
)
308 FD_CLR (fd
, &gdb_notifier
.check_masks
[1]);
309 if (file_ptr
->mask
& GDB_EXCEPTION
)
310 FD_CLR (fd
, &gdb_notifier
.check_masks
[2]);
312 /* Find current max fd. */
314 if ((fd
+ 1) == gdb_notifier
.num_fds
)
316 gdb_notifier
.num_fds
--;
317 for (i
= gdb_notifier
.num_fds
; i
; i
--)
319 if (FD_ISSET (i
- 1, &gdb_notifier
.check_masks
[0])
320 || FD_ISSET (i
- 1, &gdb_notifier
.check_masks
[1])
321 || FD_ISSET (i
- 1, &gdb_notifier
.check_masks
[2]))
324 gdb_notifier
.num_fds
= i
;
327 /* Deactivate the file descriptor, by clearing its mask, so that it
328 will not fire again. */
332 /* Get rid of the file handler in the file handler list. */
333 if (file_ptr
== gdb_notifier
.first_file_handler
)
334 gdb_notifier
.first_file_handler
= file_ptr
->next_file
;
337 for (prev_ptr
= gdb_notifier
.first_file_handler
;
338 prev_ptr
->next_file
!= file_ptr
;
339 prev_ptr
= prev_ptr
->next_file
)
341 prev_ptr
->next_file
= file_ptr
->next_file
;
346 /* Handle the given event by calling the procedure associated to the
347 corresponding file handler. Called by process_event indirectly,
348 through event_ptr->proc. EVENT_FILE_DESC is file descriptor of the
349 event in the front of the event queue. */
352 handle_file_event (int event_file_desc
)
354 file_handler
*file_ptr
;
357 /* Search the file handler list to find one that matches the fd in
359 for (file_ptr
= gdb_notifier
.first_file_handler
; file_ptr
!= NULL
;
360 file_ptr
= file_ptr
->next_file
)
362 if (file_ptr
->fd
== event_file_desc
)
364 /* See if the desired events (mask) match the received
365 events (ready_mask). */
367 if (file_ptr
->ready_mask
& GDB_EXCEPTION
)
369 fprintf (stderr
, "Exception condition detected on fd %d\n",
375 mask
= file_ptr
->ready_mask
& file_ptr
->mask
;
377 /* Clear the received events for next time around. */
378 file_ptr
->ready_mask
= 0;
380 /* If there was a match, then call the handler. */
383 if ((*file_ptr
->proc
) (file_ptr
->error
,
384 file_ptr
->client_data
) < 0)
394 /* Create a file event, to be enqueued in the event queue for
395 processing. The procedure associated to this event is always
396 handle_file_event, which will in turn invoke the one that was
397 associated to FD when it was registered with the event loop. */
400 create_file_event (int fd
)
402 gdb_event
*file_event_ptr
;
404 file_event_ptr
= xmalloc (sizeof (gdb_event
));
405 file_event_ptr
->proc
= handle_file_event
;
406 file_event_ptr
->fd
= fd
;
407 return file_event_ptr
;
410 /* Called by do_one_event to wait for new events on the monitored file
411 descriptors. Queue file events as they are detected by the poll.
412 If there are no events, this function will block in the call to
413 select. Return -1 if there are no files descriptors to monitor,
414 otherwise return 0. */
417 wait_for_event (void)
419 file_handler
*file_ptr
;
420 gdb_event
*file_event_ptr
;
423 /* Make sure all output is done before getting another event. */
427 if (gdb_notifier
.num_fds
== 0)
430 gdb_notifier
.ready_masks
[0] = gdb_notifier
.check_masks
[0];
431 gdb_notifier
.ready_masks
[1] = gdb_notifier
.check_masks
[1];
432 gdb_notifier
.ready_masks
[2] = gdb_notifier
.check_masks
[2];
433 num_found
= select (gdb_notifier
.num_fds
,
434 &gdb_notifier
.ready_masks
[0],
435 &gdb_notifier
.ready_masks
[1],
436 &gdb_notifier
.ready_masks
[2],
439 /* Clear the masks after an error from select. */
442 FD_ZERO (&gdb_notifier
.ready_masks
[0]);
443 FD_ZERO (&gdb_notifier
.ready_masks
[1]);
444 FD_ZERO (&gdb_notifier
.ready_masks
[2]);
446 /* Dont print anything if we got a signal, let gdb handle
449 perror_with_name ("select");
453 /* Enqueue all detected file events. */
455 for (file_ptr
= gdb_notifier
.first_file_handler
;
456 file_ptr
!= NULL
&& num_found
> 0;
457 file_ptr
= file_ptr
->next_file
)
461 if (FD_ISSET (file_ptr
->fd
, &gdb_notifier
.ready_masks
[0]))
462 mask
|= GDB_READABLE
;
463 if (FD_ISSET (file_ptr
->fd
, &gdb_notifier
.ready_masks
[1]))
464 mask
|= GDB_WRITABLE
;
465 if (FD_ISSET (file_ptr
->fd
, &gdb_notifier
.ready_masks
[2]))
466 mask
|= GDB_EXCEPTION
;
473 /* Enqueue an event only if this is still a new event for this
476 if (file_ptr
->ready_mask
== 0)
478 file_event_ptr
= create_file_event (file_ptr
->fd
);
479 async_queue_event (file_event_ptr
);
481 file_ptr
->ready_mask
= mask
;
487 /* Start up the event loop. This is the entry point to the event
491 start_event_loop (void)
493 /* Loop until there is nothing to do. This is the entry point to
494 the event loop engine. If nothing is ready at this time, wait
495 for something to happen (via wait_for_event), then process it.
496 Return when there are no longer event sources to wait for. */
500 /* Any events already waiting in the queue? */
501 int res
= process_event ();
503 /* Did the event handler want the event loop to stop? */
510 /* Wait for a new event. If wait_for_event returns -1, we
511 should get out because this means that there are no event
512 sources left. This will make the event loop stop, and the
515 if (wait_for_event () < 0)
519 /* We are done with the event loop. There are no more event sources
520 to listen to. So we exit gdbserver. */