1 /* Event loop machinery for the remote server for GDB.
2 Copyright (C) 1999-2002, 2005-2008, 2010-2012 Free Software
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
) (gdb_fildes_t
);
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 /* Callbacks are just routines that are executed before waiting for the
145 next event. In GDB this is struct gdb_timer. We don't need timers
146 so rather than copy all that complexity in gdbserver, we provide what
147 we need, but we do so in a way that if/when the day comes that we need
148 that complexity, it'll be easier to add - replace callbacks with timers
149 and use a delta of zero (which is all gdb currently uses timers for anyway).
151 PROC will be executed before gdbserver goes to sleep to wait for the
154 struct callback_event
157 callback_handler_func
*proc
;
158 gdb_client_data
*data
;
159 struct callback_event
*next
;
162 /* Table of registered callbacks. */
166 struct callback_event
*first
;
167 struct callback_event
*last
;
169 /* Id of the last callback created. */
174 /* Insert an event object into the gdb event queue.
176 EVENT_PTR points to the event to be inserted into the queue. The
177 caller must allocate memory for the event. It is freed after the
178 event has ben handled. Events in the queue will be processed head
179 to tail, therefore, events will be processed first in first
183 async_queue_event (gdb_event
*event_ptr
)
185 /* The event will become the new last_event. */
187 event_ptr
->next_event
= NULL
;
188 if (event_queue
.first_event
== NULL
)
189 event_queue
.first_event
= event_ptr
;
191 event_queue
.last_event
->next_event
= event_ptr
;
192 event_queue
.last_event
= event_ptr
;
195 /* Process one event. If an event was processed, 1 is returned
196 otherwise 0 is returned. Scan the queue from head to tail,
197 processing therefore the high priority events first, by invoking
198 the associated event handler procedure. */
203 gdb_event
*event_ptr
, *prev_ptr
;
204 event_handler_func
*proc
;
207 /* Look in the event queue to find an event that is ready
210 for (event_ptr
= event_queue
.first_event
;
212 event_ptr
= event_ptr
->next_event
)
214 /* Call the handler for the event. */
216 proc
= event_ptr
->proc
;
219 /* Let's get rid of the event from the event queue. We need to
220 do this now because while processing the event, since the
221 proc function could end up jumping out to the caller of this
222 function. In that case, we would have on the event queue an
223 event which has been processed, but not deleted. */
225 if (event_queue
.first_event
== event_ptr
)
227 event_queue
.first_event
= event_ptr
->next_event
;
228 if (event_ptr
->next_event
== NULL
)
229 event_queue
.last_event
= NULL
;
233 prev_ptr
= event_queue
.first_event
;
234 while (prev_ptr
->next_event
!= event_ptr
)
235 prev_ptr
= prev_ptr
->next_event
;
237 prev_ptr
->next_event
= event_ptr
->next_event
;
238 if (event_ptr
->next_event
== NULL
)
239 event_queue
.last_event
= prev_ptr
;
243 /* Now call the procedure associated with the event. */
249 /* This is the case if there are no event on the event queue. */
253 /* Append PROC to the callback list.
254 The result is the "id" of the callback that can be passed back to
255 delete_callback_event. */
258 append_callback_event (callback_handler_func
*proc
, gdb_client_data data
)
260 struct callback_event
*event_ptr
;
262 event_ptr
= xmalloc (sizeof (*event_ptr
));
263 event_ptr
->id
= callback_list
.num_callbacks
++;
264 event_ptr
->proc
= proc
;
265 event_ptr
->data
= data
;
266 event_ptr
->next
= NULL
;
267 if (callback_list
.first
== NULL
)
268 callback_list
.first
= event_ptr
;
269 if (callback_list
.last
!= NULL
)
270 callback_list
.last
->next
= event_ptr
;
271 callback_list
.last
= event_ptr
;
272 return event_ptr
->id
;
275 /* Delete callback ID.
276 It is not an error callback ID doesn't exist. */
279 delete_callback_event (int id
)
281 struct callback_event
**p
;
283 for (p
= &callback_list
.first
; *p
!= NULL
; p
= &(*p
)->next
)
285 struct callback_event
*event_ptr
= *p
;
287 if (event_ptr
->id
== id
)
289 *p
= event_ptr
->next
;
290 if (event_ptr
== callback_list
.last
)
291 callback_list
.last
= NULL
;
298 /* Run the next callback.
299 The result is 1 if a callback was called and event processing
300 should continue, -1 if the callback wants the event loop to exit,
301 and 0 if there are no more callbacks. */
304 process_callback (void)
306 struct callback_event
*event_ptr
;
308 event_ptr
= callback_list
.first
;
309 if (event_ptr
!= NULL
)
311 callback_handler_func
*proc
= event_ptr
->proc
;
312 gdb_client_data
*data
= event_ptr
->data
;
314 /* Remove the event before calling PROC,
315 more events may get added by PROC. */
316 callback_list
.first
= event_ptr
->next
;
317 if (callback_list
.first
== NULL
)
318 callback_list
.last
= NULL
;
328 /* Add a file handler/descriptor to the list of descriptors we are
329 interested in. FD is the file descriptor for the file/stream to be
330 listened to. MASK is a combination of READABLE, WRITABLE,
331 EXCEPTION. PROC is the procedure that will be called when an event
332 occurs for FD. CLIENT_DATA is the argument to pass to PROC. */
335 create_file_handler (gdb_fildes_t fd
, int mask
, handler_func
*proc
,
336 gdb_client_data client_data
)
338 file_handler
*file_ptr
;
340 /* Do we already have a file handler for this file? (We may be
341 changing its associated procedure). */
342 for (file_ptr
= gdb_notifier
.first_file_handler
;
344 file_ptr
= file_ptr
->next_file
)
345 if (file_ptr
->fd
== fd
)
348 /* It is a new file descriptor. Add it to the list. Otherwise,
349 just change the data associated with it. */
350 if (file_ptr
== NULL
)
352 file_ptr
= xmalloc (sizeof (*file_ptr
));
354 file_ptr
->ready_mask
= 0;
355 file_ptr
->next_file
= gdb_notifier
.first_file_handler
;
356 gdb_notifier
.first_file_handler
= file_ptr
;
358 if (mask
& GDB_READABLE
)
359 FD_SET (fd
, &gdb_notifier
.check_masks
[0]);
361 FD_CLR (fd
, &gdb_notifier
.check_masks
[0]);
363 if (mask
& GDB_WRITABLE
)
364 FD_SET (fd
, &gdb_notifier
.check_masks
[1]);
366 FD_CLR (fd
, &gdb_notifier
.check_masks
[1]);
368 if (mask
& GDB_EXCEPTION
)
369 FD_SET (fd
, &gdb_notifier
.check_masks
[2]);
371 FD_CLR (fd
, &gdb_notifier
.check_masks
[2]);
373 if (gdb_notifier
.num_fds
<= fd
)
374 gdb_notifier
.num_fds
= fd
+ 1;
377 file_ptr
->proc
= proc
;
378 file_ptr
->client_data
= client_data
;
379 file_ptr
->mask
= mask
;
382 /* Wrapper function for create_file_handler. */
385 add_file_handler (gdb_fildes_t fd
,
386 handler_func
*proc
, gdb_client_data client_data
)
388 create_file_handler (fd
, GDB_READABLE
| GDB_EXCEPTION
, proc
, client_data
);
391 /* Remove the file descriptor FD from the list of monitored fd's:
392 i.e. we don't care anymore about events on the FD. */
395 delete_file_handler (gdb_fildes_t fd
)
397 file_handler
*file_ptr
, *prev_ptr
= NULL
;
400 /* Find the entry for the given file. */
402 for (file_ptr
= gdb_notifier
.first_file_handler
;
404 file_ptr
= file_ptr
->next_file
)
405 if (file_ptr
->fd
== fd
)
408 if (file_ptr
== NULL
)
411 if (file_ptr
->mask
& GDB_READABLE
)
412 FD_CLR (fd
, &gdb_notifier
.check_masks
[0]);
413 if (file_ptr
->mask
& GDB_WRITABLE
)
414 FD_CLR (fd
, &gdb_notifier
.check_masks
[1]);
415 if (file_ptr
->mask
& GDB_EXCEPTION
)
416 FD_CLR (fd
, &gdb_notifier
.check_masks
[2]);
418 /* Find current max fd. */
420 if ((fd
+ 1) == gdb_notifier
.num_fds
)
422 gdb_notifier
.num_fds
--;
423 for (i
= gdb_notifier
.num_fds
; i
; i
--)
425 if (FD_ISSET (i
- 1, &gdb_notifier
.check_masks
[0])
426 || FD_ISSET (i
- 1, &gdb_notifier
.check_masks
[1])
427 || FD_ISSET (i
- 1, &gdb_notifier
.check_masks
[2]))
430 gdb_notifier
.num_fds
= i
;
433 /* Deactivate the file descriptor, by clearing its mask, so that it
434 will not fire again. */
438 /* Get rid of the file handler in the file handler list. */
439 if (file_ptr
== gdb_notifier
.first_file_handler
)
440 gdb_notifier
.first_file_handler
= file_ptr
->next_file
;
443 for (prev_ptr
= gdb_notifier
.first_file_handler
;
444 prev_ptr
->next_file
!= file_ptr
;
445 prev_ptr
= prev_ptr
->next_file
)
447 prev_ptr
->next_file
= file_ptr
->next_file
;
452 /* Handle the given event by calling the procedure associated to the
453 corresponding file handler. Called by process_event indirectly,
454 through event_ptr->proc. EVENT_FILE_DESC is file descriptor of the
455 event in the front of the event queue. */
458 handle_file_event (gdb_fildes_t event_file_desc
)
460 file_handler
*file_ptr
;
463 /* Search the file handler list to find one that matches the fd in
465 for (file_ptr
= gdb_notifier
.first_file_handler
; file_ptr
!= NULL
;
466 file_ptr
= file_ptr
->next_file
)
468 if (file_ptr
->fd
== event_file_desc
)
470 /* See if the desired events (mask) match the received
471 events (ready_mask). */
473 if (file_ptr
->ready_mask
& GDB_EXCEPTION
)
475 fprintf (stderr
, "Exception condition detected on fd %s\n",
476 pfildes (file_ptr
->fd
));
481 mask
= file_ptr
->ready_mask
& file_ptr
->mask
;
483 /* Clear the received events for next time around. */
484 file_ptr
->ready_mask
= 0;
486 /* If there was a match, then call the handler. */
489 if ((*file_ptr
->proc
) (file_ptr
->error
,
490 file_ptr
->client_data
) < 0)
500 /* Create a file event, to be enqueued in the event queue for
501 processing. The procedure associated to this event is always
502 handle_file_event, which will in turn invoke the one that was
503 associated to FD when it was registered with the event loop. */
506 create_file_event (gdb_fildes_t fd
)
508 gdb_event
*file_event_ptr
;
510 file_event_ptr
= xmalloc (sizeof (gdb_event
));
511 file_event_ptr
->proc
= handle_file_event
;
512 file_event_ptr
->fd
= fd
;
513 return file_event_ptr
;
516 /* Called by do_one_event to wait for new events on the monitored file
517 descriptors. Queue file events as they are detected by the poll.
518 If there are no events, this function will block in the call to
519 select. Return -1 if there are no files descriptors to monitor,
520 otherwise return 0. */
523 wait_for_event (void)
525 file_handler
*file_ptr
;
526 gdb_event
*file_event_ptr
;
529 /* Make sure all output is done before getting another event. */
533 if (gdb_notifier
.num_fds
== 0)
536 gdb_notifier
.ready_masks
[0] = gdb_notifier
.check_masks
[0];
537 gdb_notifier
.ready_masks
[1] = gdb_notifier
.check_masks
[1];
538 gdb_notifier
.ready_masks
[2] = gdb_notifier
.check_masks
[2];
539 num_found
= select (gdb_notifier
.num_fds
,
540 &gdb_notifier
.ready_masks
[0],
541 &gdb_notifier
.ready_masks
[1],
542 &gdb_notifier
.ready_masks
[2],
545 /* Clear the masks after an error from select. */
548 FD_ZERO (&gdb_notifier
.ready_masks
[0]);
549 FD_ZERO (&gdb_notifier
.ready_masks
[1]);
550 FD_ZERO (&gdb_notifier
.ready_masks
[2]);
552 /* Dont print anything if we got a signal, let gdb handle
555 perror_with_name ("select");
559 /* Enqueue all detected file events. */
561 for (file_ptr
= gdb_notifier
.first_file_handler
;
562 file_ptr
!= NULL
&& num_found
> 0;
563 file_ptr
= file_ptr
->next_file
)
567 if (FD_ISSET (file_ptr
->fd
, &gdb_notifier
.ready_masks
[0]))
568 mask
|= GDB_READABLE
;
569 if (FD_ISSET (file_ptr
->fd
, &gdb_notifier
.ready_masks
[1]))
570 mask
|= GDB_WRITABLE
;
571 if (FD_ISSET (file_ptr
->fd
, &gdb_notifier
.ready_masks
[2]))
572 mask
|= GDB_EXCEPTION
;
579 /* Enqueue an event only if this is still a new event for this
582 if (file_ptr
->ready_mask
== 0)
584 file_event_ptr
= create_file_event (file_ptr
->fd
);
585 async_queue_event (file_event_ptr
);
587 file_ptr
->ready_mask
= mask
;
593 /* Start up the event loop. This is the entry point to the event
597 start_event_loop (void)
599 /* Loop until there is nothing to do. This is the entry point to
600 the event loop engine. If nothing is ready at this time, wait
601 for something to happen (via wait_for_event), then process it.
602 Return when there are no longer event sources to wait for. */
606 /* Any events already waiting in the queue? */
607 int res
= process_event ();
609 /* Did the event handler want the event loop to stop? */
616 /* Process any queued callbacks before we go to sleep. */
617 res
= process_callback ();
619 /* Did the callback want the event loop to stop? */
626 /* Wait for a new event. If wait_for_event returns -1, we
627 should get out because this means that there are no event
628 sources left. This will make the event loop stop, and the
631 if (wait_for_event () < 0)
635 /* We are done with the event loop. There are no more event sources
636 to listen to. So we exit gdbserver. */