1 /* Event loop machinery for GDB, the GNU debugger.
2 Copyright (C) 1999-2014 Free Software Foundation, Inc.
3 Written by Elena Zannoni <ezannoni@cygnus.com> of Cygnus Solutions.
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/>. */
21 #include "event-loop.h"
22 #include "event-top.h"
26 #if defined (HAVE_POLL_H)
28 #elif defined (HAVE_SYS_POLL_H)
33 #include <sys/types.h>
37 #include "exceptions.h"
38 #include "gdb_assert.h"
39 #include "gdb_select.h"
42 /* Tell create_file_handler what events we are interested in.
43 This is used by the select version of the event loop. */
45 #define GDB_READABLE (1<<1)
46 #define GDB_WRITABLE (1<<2)
47 #define GDB_EXCEPTION (1<<3)
49 /* Data point to pass to the event handler. */
50 typedef union event_data
56 typedef struct gdb_event gdb_event
;
57 typedef void (event_handler_func
) (event_data
);
59 /* Event for the GDB event system. Events are queued by calling
60 async_queue_event and serviced later on by gdb_do_one_event. An
61 event can be, for instance, a file descriptor becoming ready to be
62 read. Servicing an event simply means that the procedure PROC will
63 be called. We have 2 queues, one for file handlers that we listen
64 to in the event loop, and one for the file handlers+events that are
65 ready. The procedure PROC associated with each event is dependant
66 of the event source. In the case of monitored file descriptors, it
67 is always the same (handle_file_event). Its duty is to invoke the
68 handler associated with the file descriptor whose state change
69 generated the event, plus doing other cleanups and such. In the
70 case of async signal handlers, it is
71 invoke_async_signal_handler. */
73 typedef struct gdb_event
75 /* Procedure to call to service this event. */
76 event_handler_func
*proc
;
78 /* Data to pass to the event handler. */
82 /* Information about each file descriptor we register with the event
85 typedef struct file_handler
87 int fd
; /* File descriptor. */
88 int mask
; /* Events we want to monitor: POLLIN, etc. */
89 int ready_mask
; /* Events that have been seen since
91 handler_func
*proc
; /* Procedure to call when fd is ready. */
92 gdb_client_data client_data
; /* Argument to pass to proc. */
93 int error
; /* Was an error detected on this fd? */
94 struct file_handler
*next_file
; /* Next registered file descriptor. */
98 /* PROC is a function to be invoked when the READY flag is set. This
99 happens when there has been a signal and the corresponding signal
100 handler has 'triggered' this async_signal_handler for execution.
101 The actual work to be done in response to a signal will be carried
102 out by PROC at a later time, within process_event. This provides a
103 deferred execution of signal handlers.
105 Async_init_signals takes care of setting up such an
106 async_signal_handler for each interesting signal. */
108 typedef struct async_signal_handler
110 int ready
; /* If ready, call this handler
111 from the main event loop, using
112 invoke_async_handler. */
113 struct async_signal_handler
*next_handler
; /* Ptr to next handler. */
114 sig_handler_func
*proc
; /* Function to call to do the work. */
115 gdb_client_data client_data
; /* Argument to async_handler_func. */
117 async_signal_handler
;
119 /* PROC is a function to be invoked when the READY flag is set. This
120 happens when the event has been marked with
121 MARK_ASYNC_EVENT_HANDLER. The actual work to be done in response
122 to an event will be carried out by PROC at a later time, within
123 process_event. This provides a deferred execution of event
125 typedef struct async_event_handler
127 /* If ready, call this handler from the main event loop, using
128 invoke_event_handler. */
131 /* Point to next handler. */
132 struct async_event_handler
*next_handler
;
134 /* Function to call to do the work. */
135 async_event_handler_func
*proc
;
137 /* Argument to PROC. */
138 gdb_client_data client_data
;
142 DECLARE_QUEUE_P(gdb_event_p
);
143 DEFINE_QUEUE_P(gdb_event_p
);
144 static QUEUE(gdb_event_p
) *event_queue
= NULL
;
146 /* Gdb_notifier is just a list of file descriptors gdb is interested in.
147 These are the input file descriptor, and the target file
148 descriptor. We have two flavors of the notifier, one for platforms
149 that have the POLL function, the other for those that don't, and
150 only support SELECT. Each of the elements in the gdb_notifier list is
151 basically a description of what kind of events gdb is interested
154 /* As of 1999-04-30 only the input file descriptor is registered with the
157 /* Do we use poll or select ? */
162 #endif /* HAVE_POLL */
164 static unsigned char use_poll
= USE_POLL
;
173 /* Ptr to head of file handler list. */
174 file_handler
*first_file_handler
;
177 /* Ptr to array of pollfd structures. */
178 struct pollfd
*poll_fds
;
180 /* Timeout in milliseconds for calls to poll(). */
184 /* Masks to be used in the next call to select.
185 Bits are set in response to calls to create_file_handler. */
186 fd_set check_masks
[3];
188 /* What file descriptors were found ready by select. */
189 fd_set ready_masks
[3];
191 /* Number of file descriptors to monitor (for poll). */
192 /* Number of valid bits (highest fd value + 1) (for select). */
195 /* Time structure for calls to select(). */
196 struct timeval select_timeout
;
198 /* Flag to tell whether the timeout should be used. */
203 /* Structure associated with a timer. PROC will be executed at the
204 first occasion after WHEN. */
209 struct gdb_timer
*next
;
210 timer_handler_func
*proc
; /* Function to call to do the work. */
211 gdb_client_data client_data
; /* Argument to async_handler_func. */
214 /* List of currently active timers. It is sorted in order of
215 increasing timers. */
218 /* Pointer to first in timer list. */
219 struct gdb_timer
*first_timer
;
221 /* Id of the last timer created. */
226 /* All the async_signal_handlers gdb is interested in are kept onto
230 /* Pointer to first in handler list. */
231 async_signal_handler
*first_handler
;
233 /* Pointer to last in handler list. */
234 async_signal_handler
*last_handler
;
238 /* All the async_event_handlers gdb is interested in are kept onto
242 /* Pointer to first in handler list. */
243 async_event_handler
*first_handler
;
245 /* Pointer to last in handler list. */
246 async_event_handler
*last_handler
;
248 async_event_handler_list
;
250 static int invoke_async_signal_handlers (void);
251 static void create_file_handler (int fd
, int mask
, handler_func
*proc
,
252 gdb_client_data client_data
);
253 static void handle_file_event (event_data data
);
254 static void check_async_event_handlers (void);
255 static int gdb_wait_for_event (int);
256 static void poll_timers (void);
259 /* Create a generic event, to be enqueued in the event queue for
260 processing. PROC is the procedure associated to the event. DATA
261 is passed to PROC upon PROC invocation. */
264 create_event (event_handler_func proc
, event_data data
)
268 event
= xmalloc (sizeof (*event
));
275 /* Create a file event, to be enqueued in the event queue for
276 processing. The procedure associated to this event is always
277 handle_file_event, which will in turn invoke the one that was
278 associated to FD when it was registered with the event loop. */
280 create_file_event (int fd
)
285 return create_event (handle_file_event
, data
);
292 gdb_event_xfree (struct gdb_event
*event
)
297 /* Initialize the event queue. */
300 initialize_event_loop (void)
302 event_queue
= QUEUE_alloc (gdb_event_p
, gdb_event_xfree
);
305 /* Process one event.
306 The event can be the next one to be serviced in the event queue,
307 or an asynchronous event handler can be invoked in response to
308 the reception of a signal.
309 If an event was processed (either way), 1 is returned otherwise
311 Scan the queue from head to tail, processing therefore the high
312 priority events first, by invoking the associated event handler
317 /* First let's see if there are any asynchronous event handlers that
318 are ready. These would be the result of invoking any of the
321 if (invoke_async_signal_handlers ())
324 /* Look in the event queue to find an event that is ready
327 if (!QUEUE_is_empty (gdb_event_p
, event_queue
))
329 /* Let's get rid of the event from the event queue. We need to
330 do this now because while processing the event, the proc
331 function could end up calling 'error' and therefore jump out
332 to the caller of this function, gdb_do_one_event. In that
333 case, we would have on the event queue an event wich has been
334 processed, but not deleted. */
335 gdb_event
*event_ptr
= QUEUE_deque (gdb_event_p
, event_queue
);
336 /* Call the handler for the event. */
337 event_handler_func
*proc
= event_ptr
->proc
;
338 event_data data
= event_ptr
->data
;
340 gdb_event_xfree (event_ptr
);
342 /* Now call the procedure associated with the event. */
347 /* This is the case if there are no event on the event queue. */
351 /* Process one high level event. If nothing is ready at this time,
352 wait for something to happen (via gdb_wait_for_event), then process
353 it. Returns >0 if something was done otherwise returns <0 (this
354 can happen if there are no event sources to wait for). */
357 gdb_do_one_event (void)
359 static int event_source_head
= 0;
360 const int number_of_sources
= 3;
363 /* Any events already waiting in the queue? */
364 if (process_event ())
367 /* To level the fairness across event sources, we poll them in a
368 round-robin fashion. */
369 for (current
= 0; current
< number_of_sources
; current
++)
371 switch (event_source_head
)
374 /* Are any timers that are ready? If so, put an event on the
379 /* Are there events already waiting to be collected on the
380 monitored file descriptors? */
381 gdb_wait_for_event (0);
384 /* Are there any asynchronous event handlers ready? */
385 check_async_event_handlers ();
390 if (event_source_head
== number_of_sources
)
391 event_source_head
= 0;
394 /* Handle any new events collected. */
395 if (process_event ())
398 /* Block waiting for a new event. If gdb_wait_for_event returns -1,
399 we should get out because this means that there are no event
400 sources left. This will make the event loop stop, and the
403 if (gdb_wait_for_event (1) < 0)
406 /* Handle any new events occurred while waiting. */
407 if (process_event ())
410 /* If gdb_wait_for_event has returned 1, it means that one event has
411 been handled. We break out of the loop. */
415 /* Start up the event loop. This is the entry point to the event loop
416 from the command loop. */
419 start_event_loop (void)
421 /* Loop until there is nothing to do. This is the entry point to
422 the event loop engine. gdb_do_one_event will process one event
423 for each invocation. It blocks waiting for an event and then
427 volatile struct gdb_exception ex
;
430 TRY_CATCH (ex
, RETURN_MASK_ALL
)
432 result
= gdb_do_one_event ();
436 exception_print (gdb_stderr
, ex
);
438 /* If any exception escaped to here, we better enable
439 stdin. Otherwise, any command that calls async_disable_stdin,
440 and then throws, will leave stdin inoperable. */
441 async_enable_stdin ();
442 /* If we long-jumped out of do_one_event, we probably didn't
443 get around to resetting the prompt, which leaves readline
444 in a messed-up state. Reset it here. */
445 observer_notify_command_error ();
446 /* This call looks bizarre, but it is required. If the user
447 entered a command that caused an error,
448 after_char_processing_hook won't be called from
449 rl_callback_read_char_wrapper. Using a cleanup there
450 won't work, since we want this function to be called
451 after a new prompt is printed. */
452 if (after_char_processing_hook
)
453 (*after_char_processing_hook
) ();
454 /* Maybe better to set a flag to be checked somewhere as to
455 whether display the prompt or not. */
461 /* We are done with the event loop. There are no more event sources
462 to listen to. So we exit GDB. */
467 /* Wrapper function for create_file_handler, so that the caller
468 doesn't have to know implementation details about the use of poll
471 add_file_handler (int fd
, handler_func
* proc
, gdb_client_data client_data
)
480 /* Check to see if poll () is usable. If not, we'll switch to
481 use select. This can happen on systems like
482 m68k-motorola-sys, `poll' cannot be used to wait for `stdin'.
483 On m68k-motorola-sysv, tty's are not stream-based and not
487 if (poll (&fds
, 1, 0) == 1 && (fds
.revents
& POLLNVAL
))
490 internal_error (__FILE__
, __LINE__
,
491 _("use_poll without HAVE_POLL"));
492 #endif /* HAVE_POLL */
497 create_file_handler (fd
, POLLIN
, proc
, client_data
);
499 internal_error (__FILE__
, __LINE__
,
500 _("use_poll without HAVE_POLL"));
504 create_file_handler (fd
, GDB_READABLE
| GDB_EXCEPTION
,
508 /* Add a file handler/descriptor to the list of descriptors we are
511 FD is the file descriptor for the file/stream to be listened to.
513 For the poll case, MASK is a combination (OR) of POLLIN,
514 POLLRDNORM, POLLRDBAND, POLLPRI, POLLOUT, POLLWRNORM, POLLWRBAND:
515 these are the events we are interested in. If any of them occurs,
516 proc should be called.
518 For the select case, MASK is a combination of READABLE, WRITABLE,
519 EXCEPTION. PROC is the procedure that will be called when an event
520 occurs for FD. CLIENT_DATA is the argument to pass to PROC. */
523 create_file_handler (int fd
, int mask
, handler_func
* proc
,
524 gdb_client_data client_data
)
526 file_handler
*file_ptr
;
528 /* Do we already have a file handler for this file? (We may be
529 changing its associated procedure). */
530 for (file_ptr
= gdb_notifier
.first_file_handler
; file_ptr
!= NULL
;
531 file_ptr
= file_ptr
->next_file
)
533 if (file_ptr
->fd
== fd
)
537 /* It is a new file descriptor. Add it to the list. Otherwise, just
538 change the data associated with it. */
539 if (file_ptr
== NULL
)
541 file_ptr
= (file_handler
*) xmalloc (sizeof (file_handler
));
543 file_ptr
->ready_mask
= 0;
544 file_ptr
->next_file
= gdb_notifier
.first_file_handler
;
545 gdb_notifier
.first_file_handler
= file_ptr
;
550 gdb_notifier
.num_fds
++;
551 if (gdb_notifier
.poll_fds
)
552 gdb_notifier
.poll_fds
=
553 (struct pollfd
*) xrealloc (gdb_notifier
.poll_fds
,
554 (gdb_notifier
.num_fds
555 * sizeof (struct pollfd
)));
557 gdb_notifier
.poll_fds
=
558 (struct pollfd
*) xmalloc (sizeof (struct pollfd
));
559 (gdb_notifier
.poll_fds
+ gdb_notifier
.num_fds
- 1)->fd
= fd
;
560 (gdb_notifier
.poll_fds
+ gdb_notifier
.num_fds
- 1)->events
= mask
;
561 (gdb_notifier
.poll_fds
+ gdb_notifier
.num_fds
- 1)->revents
= 0;
563 internal_error (__FILE__
, __LINE__
,
564 _("use_poll without HAVE_POLL"));
565 #endif /* HAVE_POLL */
569 if (mask
& GDB_READABLE
)
570 FD_SET (fd
, &gdb_notifier
.check_masks
[0]);
572 FD_CLR (fd
, &gdb_notifier
.check_masks
[0]);
574 if (mask
& GDB_WRITABLE
)
575 FD_SET (fd
, &gdb_notifier
.check_masks
[1]);
577 FD_CLR (fd
, &gdb_notifier
.check_masks
[1]);
579 if (mask
& GDB_EXCEPTION
)
580 FD_SET (fd
, &gdb_notifier
.check_masks
[2]);
582 FD_CLR (fd
, &gdb_notifier
.check_masks
[2]);
584 if (gdb_notifier
.num_fds
<= fd
)
585 gdb_notifier
.num_fds
= fd
+ 1;
589 file_ptr
->proc
= proc
;
590 file_ptr
->client_data
= client_data
;
591 file_ptr
->mask
= mask
;
594 /* Remove the file descriptor FD from the list of monitored fd's:
595 i.e. we don't care anymore about events on the FD. */
597 delete_file_handler (int fd
)
599 file_handler
*file_ptr
, *prev_ptr
= NULL
;
603 struct pollfd
*new_poll_fds
;
606 /* Find the entry for the given file. */
608 for (file_ptr
= gdb_notifier
.first_file_handler
; file_ptr
!= NULL
;
609 file_ptr
= file_ptr
->next_file
)
611 if (file_ptr
->fd
== fd
)
615 if (file_ptr
== NULL
)
621 /* Create a new poll_fds array by copying every fd's information
622 but the one we want to get rid of. */
624 new_poll_fds
= (struct pollfd
*)
625 xmalloc ((gdb_notifier
.num_fds
- 1) * sizeof (struct pollfd
));
627 for (i
= 0, j
= 0; i
< gdb_notifier
.num_fds
; i
++)
629 if ((gdb_notifier
.poll_fds
+ i
)->fd
!= fd
)
631 (new_poll_fds
+ j
)->fd
= (gdb_notifier
.poll_fds
+ i
)->fd
;
632 (new_poll_fds
+ j
)->events
= (gdb_notifier
.poll_fds
+ i
)->events
;
633 (new_poll_fds
+ j
)->revents
634 = (gdb_notifier
.poll_fds
+ i
)->revents
;
638 xfree (gdb_notifier
.poll_fds
);
639 gdb_notifier
.poll_fds
= new_poll_fds
;
640 gdb_notifier
.num_fds
--;
642 internal_error (__FILE__
, __LINE__
,
643 _("use_poll without HAVE_POLL"));
644 #endif /* HAVE_POLL */
648 if (file_ptr
->mask
& GDB_READABLE
)
649 FD_CLR (fd
, &gdb_notifier
.check_masks
[0]);
650 if (file_ptr
->mask
& GDB_WRITABLE
)
651 FD_CLR (fd
, &gdb_notifier
.check_masks
[1]);
652 if (file_ptr
->mask
& GDB_EXCEPTION
)
653 FD_CLR (fd
, &gdb_notifier
.check_masks
[2]);
655 /* Find current max fd. */
657 if ((fd
+ 1) == gdb_notifier
.num_fds
)
659 gdb_notifier
.num_fds
--;
660 for (i
= gdb_notifier
.num_fds
; i
; i
--)
662 if (FD_ISSET (i
- 1, &gdb_notifier
.check_masks
[0])
663 || FD_ISSET (i
- 1, &gdb_notifier
.check_masks
[1])
664 || FD_ISSET (i
- 1, &gdb_notifier
.check_masks
[2]))
667 gdb_notifier
.num_fds
= i
;
671 /* Deactivate the file descriptor, by clearing its mask,
672 so that it will not fire again. */
676 /* Get rid of the file handler in the file handler list. */
677 if (file_ptr
== gdb_notifier
.first_file_handler
)
678 gdb_notifier
.first_file_handler
= file_ptr
->next_file
;
681 for (prev_ptr
= gdb_notifier
.first_file_handler
;
682 prev_ptr
->next_file
!= file_ptr
;
683 prev_ptr
= prev_ptr
->next_file
)
685 prev_ptr
->next_file
= file_ptr
->next_file
;
690 /* Handle the given event by calling the procedure associated to the
691 corresponding file handler. Called by process_event indirectly,
692 through event_ptr->proc. EVENT_FILE_DESC is file descriptor of the
693 event in the front of the event queue. */
695 handle_file_event (event_data data
)
697 file_handler
*file_ptr
;
702 int event_file_desc
= data
.integer
;
704 /* Search the file handler list to find one that matches the fd in
706 for (file_ptr
= gdb_notifier
.first_file_handler
; file_ptr
!= NULL
;
707 file_ptr
= file_ptr
->next_file
)
709 if (file_ptr
->fd
== event_file_desc
)
711 /* With poll, the ready_mask could have any of three events
712 set to 1: POLLHUP, POLLERR, POLLNVAL. These events
713 cannot be used in the requested event mask (events), but
714 they can be returned in the return mask (revents). We
715 need to check for those event too, and add them to the
716 mask which will be passed to the handler. */
718 /* See if the desired events (mask) match the received
719 events (ready_mask). */
724 /* POLLHUP means EOF, but can be combined with POLLIN to
725 signal more data to read. */
726 error_mask
= POLLHUP
| POLLERR
| POLLNVAL
;
727 mask
= file_ptr
->ready_mask
& (file_ptr
->mask
| error_mask
);
729 if ((mask
& (POLLERR
| POLLNVAL
)) != 0)
731 /* Work in progress. We may need to tell somebody
732 what kind of error we had. */
734 printf_unfiltered (_("Error detected on fd %d\n"),
737 printf_unfiltered (_("Invalid or non-`poll'able fd %d\n"),
744 internal_error (__FILE__
, __LINE__
,
745 _("use_poll without HAVE_POLL"));
746 #endif /* HAVE_POLL */
750 if (file_ptr
->ready_mask
& GDB_EXCEPTION
)
752 printf_unfiltered (_("Exception condition detected "
753 "on fd %d\n"), file_ptr
->fd
);
758 mask
= file_ptr
->ready_mask
& file_ptr
->mask
;
761 /* Clear the received events for next time around. */
762 file_ptr
->ready_mask
= 0;
764 /* If there was a match, then call the handler. */
766 (*file_ptr
->proc
) (file_ptr
->error
, file_ptr
->client_data
);
772 /* Called by gdb_do_one_event to wait for new events on the monitored
773 file descriptors. Queue file events as they are detected by the
774 poll. If BLOCK and if there are no events, this function will
775 block in the call to poll. Return -1 if there are no file
776 descriptors to monitor, otherwise return 0. */
778 gdb_wait_for_event (int block
)
780 file_handler
*file_ptr
;
781 gdb_event
*file_event_ptr
;
785 /* Make sure all output is done before getting another event. */
786 gdb_flush (gdb_stdout
);
787 gdb_flush (gdb_stderr
);
789 if (gdb_notifier
.num_fds
== 0)
798 timeout
= gdb_notifier
.timeout_valid
? gdb_notifier
.poll_timeout
: -1;
802 num_found
= poll (gdb_notifier
.poll_fds
,
803 (unsigned long) gdb_notifier
.num_fds
, timeout
);
805 /* Don't print anything if we get out of poll because of a
807 if (num_found
== -1 && errno
!= EINTR
)
808 perror_with_name (("poll"));
810 internal_error (__FILE__
, __LINE__
,
811 _("use_poll without HAVE_POLL"));
812 #endif /* HAVE_POLL */
816 struct timeval select_timeout
;
817 struct timeval
*timeout_p
;
820 timeout_p
= gdb_notifier
.timeout_valid
821 ? &gdb_notifier
.select_timeout
: NULL
;
824 memset (&select_timeout
, 0, sizeof (select_timeout
));
825 timeout_p
= &select_timeout
;
828 gdb_notifier
.ready_masks
[0] = gdb_notifier
.check_masks
[0];
829 gdb_notifier
.ready_masks
[1] = gdb_notifier
.check_masks
[1];
830 gdb_notifier
.ready_masks
[2] = gdb_notifier
.check_masks
[2];
831 num_found
= gdb_select (gdb_notifier
.num_fds
,
832 &gdb_notifier
.ready_masks
[0],
833 &gdb_notifier
.ready_masks
[1],
834 &gdb_notifier
.ready_masks
[2],
837 /* Clear the masks after an error from select. */
840 FD_ZERO (&gdb_notifier
.ready_masks
[0]);
841 FD_ZERO (&gdb_notifier
.ready_masks
[1]);
842 FD_ZERO (&gdb_notifier
.ready_masks
[2]);
844 /* Dont print anything if we got a signal, let gdb handle
847 perror_with_name (("select"));
851 /* Enqueue all detected file events. */
856 for (i
= 0; (i
< gdb_notifier
.num_fds
) && (num_found
> 0); i
++)
858 if ((gdb_notifier
.poll_fds
+ i
)->revents
)
863 for (file_ptr
= gdb_notifier
.first_file_handler
;
865 file_ptr
= file_ptr
->next_file
)
867 if (file_ptr
->fd
== (gdb_notifier
.poll_fds
+ i
)->fd
)
873 /* Enqueue an event only if this is still a new event for
875 if (file_ptr
->ready_mask
== 0)
877 file_event_ptr
= create_file_event (file_ptr
->fd
);
878 QUEUE_enque (gdb_event_p
, event_queue
, file_event_ptr
);
880 file_ptr
->ready_mask
= (gdb_notifier
.poll_fds
+ i
)->revents
;
884 internal_error (__FILE__
, __LINE__
,
885 _("use_poll without HAVE_POLL"));
886 #endif /* HAVE_POLL */
890 for (file_ptr
= gdb_notifier
.first_file_handler
;
891 (file_ptr
!= NULL
) && (num_found
> 0);
892 file_ptr
= file_ptr
->next_file
)
896 if (FD_ISSET (file_ptr
->fd
, &gdb_notifier
.ready_masks
[0]))
897 mask
|= GDB_READABLE
;
898 if (FD_ISSET (file_ptr
->fd
, &gdb_notifier
.ready_masks
[1]))
899 mask
|= GDB_WRITABLE
;
900 if (FD_ISSET (file_ptr
->fd
, &gdb_notifier
.ready_masks
[2]))
901 mask
|= GDB_EXCEPTION
;
908 /* Enqueue an event only if this is still a new event for
911 if (file_ptr
->ready_mask
== 0)
913 file_event_ptr
= create_file_event (file_ptr
->fd
);
914 QUEUE_enque (gdb_event_p
, event_queue
, file_event_ptr
);
916 file_ptr
->ready_mask
= mask
;
923 /* Create an asynchronous handler, allocating memory for it.
924 Return a pointer to the newly created handler.
925 This pointer will be used to invoke the handler by
926 invoke_async_signal_handler.
927 PROC is the function to call with CLIENT_DATA argument
928 whenever the handler is invoked. */
929 async_signal_handler
*
930 create_async_signal_handler (sig_handler_func
* proc
,
931 gdb_client_data client_data
)
933 async_signal_handler
*async_handler_ptr
;
936 (async_signal_handler
*) xmalloc (sizeof (async_signal_handler
));
937 async_handler_ptr
->ready
= 0;
938 async_handler_ptr
->next_handler
= NULL
;
939 async_handler_ptr
->proc
= proc
;
940 async_handler_ptr
->client_data
= client_data
;
941 if (sighandler_list
.first_handler
== NULL
)
942 sighandler_list
.first_handler
= async_handler_ptr
;
944 sighandler_list
.last_handler
->next_handler
= async_handler_ptr
;
945 sighandler_list
.last_handler
= async_handler_ptr
;
946 return async_handler_ptr
;
949 /* Call the handler from HANDLER immediately. This function runs
950 signal handlers when returning to the event loop would be too
953 call_async_signal_handler (struct async_signal_handler
*handler
)
955 (*handler
->proc
) (handler
->client_data
);
958 /* Mark the handler (ASYNC_HANDLER_PTR) as ready. This information
959 will be used when the handlers are invoked, after we have waited
960 for some event. The caller of this function is the interrupt
961 handler associated with a signal. */
963 mark_async_signal_handler (async_signal_handler
* async_handler_ptr
)
965 async_handler_ptr
->ready
= 1;
968 /* Call all the handlers that are ready. Returns true if any was
971 invoke_async_signal_handlers (void)
973 async_signal_handler
*async_handler_ptr
;
976 /* Invoke ready handlers. */
980 for (async_handler_ptr
= sighandler_list
.first_handler
;
981 async_handler_ptr
!= NULL
;
982 async_handler_ptr
= async_handler_ptr
->next_handler
)
984 if (async_handler_ptr
->ready
)
987 if (async_handler_ptr
== NULL
)
990 async_handler_ptr
->ready
= 0;
991 (*async_handler_ptr
->proc
) (async_handler_ptr
->client_data
);
997 /* Delete an asynchronous handler (ASYNC_HANDLER_PTR).
998 Free the space allocated for it. */
1000 delete_async_signal_handler (async_signal_handler
** async_handler_ptr
)
1002 async_signal_handler
*prev_ptr
;
1004 if (sighandler_list
.first_handler
== (*async_handler_ptr
))
1006 sighandler_list
.first_handler
= (*async_handler_ptr
)->next_handler
;
1007 if (sighandler_list
.first_handler
== NULL
)
1008 sighandler_list
.last_handler
= NULL
;
1012 prev_ptr
= sighandler_list
.first_handler
;
1013 while (prev_ptr
&& prev_ptr
->next_handler
!= (*async_handler_ptr
))
1014 prev_ptr
= prev_ptr
->next_handler
;
1015 gdb_assert (prev_ptr
);
1016 prev_ptr
->next_handler
= (*async_handler_ptr
)->next_handler
;
1017 if (sighandler_list
.last_handler
== (*async_handler_ptr
))
1018 sighandler_list
.last_handler
= prev_ptr
;
1020 xfree ((*async_handler_ptr
));
1021 (*async_handler_ptr
) = NULL
;
1024 /* Create an asynchronous event handler, allocating memory for it.
1025 Return a pointer to the newly created handler. PROC is the
1026 function to call with CLIENT_DATA argument whenever the handler is
1028 async_event_handler
*
1029 create_async_event_handler (async_event_handler_func
*proc
,
1030 gdb_client_data client_data
)
1032 async_event_handler
*h
;
1034 h
= xmalloc (sizeof (*h
));
1036 h
->next_handler
= NULL
;
1038 h
->client_data
= client_data
;
1039 if (async_event_handler_list
.first_handler
== NULL
)
1040 async_event_handler_list
.first_handler
= h
;
1042 async_event_handler_list
.last_handler
->next_handler
= h
;
1043 async_event_handler_list
.last_handler
= h
;
1047 /* Mark the handler (ASYNC_HANDLER_PTR) as ready. This information
1048 will be used by gdb_do_one_event. The caller will be whoever
1049 created the event source, and wants to signal that the event is
1050 ready to be handled. */
1052 mark_async_event_handler (async_event_handler
*async_handler_ptr
)
1054 async_handler_ptr
->ready
= 1;
1057 struct async_event_handler_data
1059 async_event_handler_func
* proc
;
1060 gdb_client_data client_data
;
1064 invoke_async_event_handler (event_data data
)
1066 struct async_event_handler_data
*hdata
= data
.ptr
;
1067 async_event_handler_func
* proc
= hdata
->proc
;
1068 gdb_client_data client_data
= hdata
->client_data
;
1071 (*proc
) (client_data
);
1074 /* Check if any asynchronous event handlers are ready, and queue
1075 events in the ready queue for any that are. */
1077 check_async_event_handlers (void)
1079 async_event_handler
*async_handler_ptr
;
1080 struct async_event_handler_data
*hdata
;
1081 struct gdb_event
*event_ptr
;
1084 for (async_handler_ptr
= async_event_handler_list
.first_handler
;
1085 async_handler_ptr
!= NULL
;
1086 async_handler_ptr
= async_handler_ptr
->next_handler
)
1088 if (async_handler_ptr
->ready
)
1090 async_handler_ptr
->ready
= 0;
1092 hdata
= xmalloc (sizeof (*hdata
));
1094 hdata
->proc
= async_handler_ptr
->proc
;
1095 hdata
->client_data
= async_handler_ptr
->client_data
;
1099 event_ptr
= create_event (invoke_async_event_handler
, data
);
1100 QUEUE_enque (gdb_event_p
, event_queue
, event_ptr
);
1105 /* Delete an asynchronous handler (ASYNC_HANDLER_PTR).
1106 Free the space allocated for it. */
1108 delete_async_event_handler (async_event_handler
**async_handler_ptr
)
1110 async_event_handler
*prev_ptr
;
1112 if (async_event_handler_list
.first_handler
== *async_handler_ptr
)
1114 async_event_handler_list
.first_handler
1115 = (*async_handler_ptr
)->next_handler
;
1116 if (async_event_handler_list
.first_handler
== NULL
)
1117 async_event_handler_list
.last_handler
= NULL
;
1121 prev_ptr
= async_event_handler_list
.first_handler
;
1122 while (prev_ptr
&& prev_ptr
->next_handler
!= *async_handler_ptr
)
1123 prev_ptr
= prev_ptr
->next_handler
;
1124 gdb_assert (prev_ptr
);
1125 prev_ptr
->next_handler
= (*async_handler_ptr
)->next_handler
;
1126 if (async_event_handler_list
.last_handler
== (*async_handler_ptr
))
1127 async_event_handler_list
.last_handler
= prev_ptr
;
1129 xfree (*async_handler_ptr
);
1130 *async_handler_ptr
= NULL
;
1133 /* Create a timer that will expire in MILLISECONDS from now. When the
1134 timer is ready, PROC will be executed. At creation, the timer is
1135 aded to the timers queue. This queue is kept sorted in order of
1136 increasing timers. Return a handle to the timer struct. */
1138 create_timer (int milliseconds
, timer_handler_func
* proc
,
1139 gdb_client_data client_data
)
1141 struct gdb_timer
*timer_ptr
, *timer_index
, *prev_timer
;
1142 struct timeval time_now
, delta
;
1144 /* Compute seconds. */
1145 delta
.tv_sec
= milliseconds
/ 1000;
1146 /* Compute microseconds. */
1147 delta
.tv_usec
= (milliseconds
% 1000) * 1000;
1149 gettimeofday (&time_now
, NULL
);
1151 timer_ptr
= (struct gdb_timer
*) xmalloc (sizeof (*timer_ptr
));
1152 timer_ptr
->when
.tv_sec
= time_now
.tv_sec
+ delta
.tv_sec
;
1153 timer_ptr
->when
.tv_usec
= time_now
.tv_usec
+ delta
.tv_usec
;
1155 if (timer_ptr
->when
.tv_usec
>= 1000000)
1157 timer_ptr
->when
.tv_sec
+= 1;
1158 timer_ptr
->when
.tv_usec
-= 1000000;
1160 timer_ptr
->proc
= proc
;
1161 timer_ptr
->client_data
= client_data
;
1162 timer_list
.num_timers
++;
1163 timer_ptr
->timer_id
= timer_list
.num_timers
;
1165 /* Now add the timer to the timer queue, making sure it is sorted in
1166 increasing order of expiration. */
1168 for (timer_index
= timer_list
.first_timer
;
1169 timer_index
!= NULL
;
1170 timer_index
= timer_index
->next
)
1172 /* If the seconds field is greater or if it is the same, but the
1173 microsecond field is greater. */
1174 if ((timer_index
->when
.tv_sec
> timer_ptr
->when
.tv_sec
)
1175 || ((timer_index
->when
.tv_sec
== timer_ptr
->when
.tv_sec
)
1176 && (timer_index
->when
.tv_usec
> timer_ptr
->when
.tv_usec
)))
1180 if (timer_index
== timer_list
.first_timer
)
1182 timer_ptr
->next
= timer_list
.first_timer
;
1183 timer_list
.first_timer
= timer_ptr
;
1188 for (prev_timer
= timer_list
.first_timer
;
1189 prev_timer
->next
!= timer_index
;
1190 prev_timer
= prev_timer
->next
)
1193 prev_timer
->next
= timer_ptr
;
1194 timer_ptr
->next
= timer_index
;
1197 gdb_notifier
.timeout_valid
= 0;
1198 return timer_ptr
->timer_id
;
1201 /* There is a chance that the creator of the timer wants to get rid of
1202 it before it expires. */
1204 delete_timer (int id
)
1206 struct gdb_timer
*timer_ptr
, *prev_timer
= NULL
;
1208 /* Find the entry for the given timer. */
1210 for (timer_ptr
= timer_list
.first_timer
; timer_ptr
!= NULL
;
1211 timer_ptr
= timer_ptr
->next
)
1213 if (timer_ptr
->timer_id
== id
)
1217 if (timer_ptr
== NULL
)
1219 /* Get rid of the timer in the timer list. */
1220 if (timer_ptr
== timer_list
.first_timer
)
1221 timer_list
.first_timer
= timer_ptr
->next
;
1224 for (prev_timer
= timer_list
.first_timer
;
1225 prev_timer
->next
!= timer_ptr
;
1226 prev_timer
= prev_timer
->next
)
1228 prev_timer
->next
= timer_ptr
->next
;
1232 gdb_notifier
.timeout_valid
= 0;
1235 /* When a timer event is put on the event queue, it will be handled by
1236 this function. Just call the associated procedure and delete the
1237 timer event from the event queue. Repeat this for each timer that
1240 handle_timer_event (event_data dummy
)
1242 struct timeval time_now
;
1243 struct gdb_timer
*timer_ptr
, *saved_timer
;
1245 gettimeofday (&time_now
, NULL
);
1246 timer_ptr
= timer_list
.first_timer
;
1248 while (timer_ptr
!= NULL
)
1250 if ((timer_ptr
->when
.tv_sec
> time_now
.tv_sec
)
1251 || ((timer_ptr
->when
.tv_sec
== time_now
.tv_sec
)
1252 && (timer_ptr
->when
.tv_usec
> time_now
.tv_usec
)))
1255 /* Get rid of the timer from the beginning of the list. */
1256 timer_list
.first_timer
= timer_ptr
->next
;
1257 saved_timer
= timer_ptr
;
1258 timer_ptr
= timer_ptr
->next
;
1259 /* Call the procedure associated with that timer. */
1260 (*saved_timer
->proc
) (saved_timer
->client_data
);
1261 xfree (saved_timer
);
1264 gdb_notifier
.timeout_valid
= 0;
1267 /* Check whether any timers in the timers queue are ready. If at least
1268 one timer is ready, stick an event onto the event queue. Even in
1269 case more than one timer is ready, one event is enough, because the
1270 handle_timer_event() will go through the timers list and call the
1271 procedures associated with all that have expired.l Update the
1272 timeout for the select() or poll() as well. */
1276 struct timeval time_now
, delta
;
1277 gdb_event
*event_ptr
;
1279 if (timer_list
.first_timer
!= NULL
)
1281 gettimeofday (&time_now
, NULL
);
1282 delta
.tv_sec
= timer_list
.first_timer
->when
.tv_sec
- time_now
.tv_sec
;
1283 delta
.tv_usec
= timer_list
.first_timer
->when
.tv_usec
- time_now
.tv_usec
;
1285 if (delta
.tv_usec
< 0)
1288 delta
.tv_usec
+= 1000000;
1291 /* Oops it expired already. Tell select / poll to return
1292 immediately. (Cannot simply test if delta.tv_sec is negative
1293 because time_t might be unsigned.) */
1294 if (timer_list
.first_timer
->when
.tv_sec
< time_now
.tv_sec
1295 || (timer_list
.first_timer
->when
.tv_sec
== time_now
.tv_sec
1296 && timer_list
.first_timer
->when
.tv_usec
< time_now
.tv_usec
))
1302 if (delta
.tv_sec
== 0 && delta
.tv_usec
== 0)
1304 event_ptr
= (gdb_event
*) xmalloc (sizeof (gdb_event
));
1305 event_ptr
->proc
= handle_timer_event
;
1306 event_ptr
->data
.integer
= timer_list
.first_timer
->timer_id
;
1307 QUEUE_enque (gdb_event_p
, event_queue
, event_ptr
);
1310 /* Now we need to update the timeout for select/ poll, because
1311 we don't want to sit there while this timer is expiring. */
1315 gdb_notifier
.poll_timeout
= delta
.tv_sec
* 1000;
1317 internal_error (__FILE__
, __LINE__
,
1318 _("use_poll without HAVE_POLL"));
1319 #endif /* HAVE_POLL */
1323 gdb_notifier
.select_timeout
.tv_sec
= delta
.tv_sec
;
1324 gdb_notifier
.select_timeout
.tv_usec
= delta
.tv_usec
;
1326 gdb_notifier
.timeout_valid
= 1;
1329 gdb_notifier
.timeout_valid
= 0;