1 /* Event loop machinery for GDB, the GNU debugger.
2 Copyright (C) 1999-2020 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"
23 #include "ser-event.h"
26 #if defined (HAVE_POLL_H)
28 #elif defined (HAVE_SYS_POLL_H)
33 #include <sys/types.h>
34 #include "gdbsupport/gdb_sys_time.h"
35 #include "gdbsupport/gdb_select.h"
38 /* Tell create_file_handler what events we are interested in.
39 This is used by the select version of the event loop. */
41 #define GDB_READABLE (1<<1)
42 #define GDB_WRITABLE (1<<2)
43 #define GDB_EXCEPTION (1<<3)
45 /* Information about each file descriptor we register with the event
48 typedef struct file_handler
50 int fd
; /* File descriptor. */
51 int mask
; /* Events we want to monitor: POLLIN, etc. */
52 int ready_mask
; /* Events that have been seen since
54 handler_func
*proc
; /* Procedure to call when fd is ready. */
55 gdb_client_data client_data
; /* Argument to pass to proc. */
56 int error
; /* Was an error detected on this fd? */
57 struct file_handler
*next_file
; /* Next registered file descriptor. */
61 /* PROC is a function to be invoked when the READY flag is set. This
62 happens when there has been a signal and the corresponding signal
63 handler has 'triggered' this async_signal_handler for execution.
64 The actual work to be done in response to a signal will be carried
65 out by PROC at a later time, within process_event. This provides a
66 deferred execution of signal handlers.
68 Async_init_signals takes care of setting up such an
69 async_signal_handler for each interesting signal. */
71 typedef struct async_signal_handler
73 int ready
; /* If ready, call this handler
74 from the main event loop, using
75 invoke_async_handler. */
76 struct async_signal_handler
*next_handler
; /* Ptr to next handler. */
77 sig_handler_func
*proc
; /* Function to call to do the work. */
78 gdb_client_data client_data
; /* Argument to async_handler_func. */
82 /* PROC is a function to be invoked when the READY flag is set. This
83 happens when the event has been marked with
84 MARK_ASYNC_EVENT_HANDLER. The actual work to be done in response
85 to an event will be carried out by PROC at a later time, within
86 process_event. This provides a deferred execution of event
88 typedef struct async_event_handler
90 /* If ready, call this handler from the main event loop, using
91 invoke_event_handler. */
94 /* Point to next handler. */
95 struct async_event_handler
*next_handler
;
97 /* Function to call to do the work. */
98 async_event_handler_func
*proc
;
100 /* Argument to PROC. */
101 gdb_client_data client_data
;
105 /* Gdb_notifier is just a list of file descriptors gdb is interested in.
106 These are the input file descriptor, and the target file
107 descriptor. We have two flavors of the notifier, one for platforms
108 that have the POLL function, the other for those that don't, and
109 only support SELECT. Each of the elements in the gdb_notifier list is
110 basically a description of what kind of events gdb is interested
113 /* As of 1999-04-30 only the input file descriptor is registered with the
116 /* Do we use poll or select ? */
121 #endif /* HAVE_POLL */
123 static unsigned char use_poll
= USE_POLL
;
132 /* Ptr to head of file handler list. */
133 file_handler
*first_file_handler
;
135 /* Next file handler to handle, for the select variant. To level
136 the fairness across event sources, we serve file handlers in a
137 round-robin-like fashion. The number and order of the polled
138 file handlers may change between invocations, but this is good
140 file_handler
*next_file_handler
;
143 /* Ptr to array of pollfd structures. */
144 struct pollfd
*poll_fds
;
146 /* Next file descriptor to handle, for the poll variant. To level
147 the fairness across event sources, we poll the file descriptors
148 in a round-robin-like fashion. The number and order of the
149 polled file descriptors may change between invocations, but
150 this is good enough. */
151 int next_poll_fds_index
;
153 /* Timeout in milliseconds for calls to poll(). */
157 /* Masks to be used in the next call to select.
158 Bits are set in response to calls to create_file_handler. */
159 fd_set check_masks
[3];
161 /* What file descriptors were found ready by select. */
162 fd_set ready_masks
[3];
164 /* Number of file descriptors to monitor (for poll). */
165 /* Number of valid bits (highest fd value + 1) (for select). */
168 /* Time structure for calls to select(). */
169 struct timeval select_timeout
;
171 /* Flag to tell whether the timeout should be used. */
176 /* Structure associated with a timer. PROC will be executed at the
177 first occasion after WHEN. */
180 std::chrono::steady_clock::time_point when
;
182 struct gdb_timer
*next
;
183 timer_handler_func
*proc
; /* Function to call to do the work. */
184 gdb_client_data client_data
; /* Argument to async_handler_func. */
187 /* List of currently active timers. It is sorted in order of
188 increasing timers. */
191 /* Pointer to first in timer list. */
192 struct gdb_timer
*first_timer
;
194 /* Id of the last timer created. */
199 /* All the async_signal_handlers gdb is interested in are kept onto
203 /* Pointer to first in handler list. */
204 async_signal_handler
*first_handler
;
206 /* Pointer to last in handler list. */
207 async_signal_handler
*last_handler
;
211 /* All the async_event_handlers gdb is interested in are kept onto
215 /* Pointer to first in handler list. */
216 async_event_handler
*first_handler
;
218 /* Pointer to last in handler list. */
219 async_event_handler
*last_handler
;
221 async_event_handler_list
;
223 static int invoke_async_signal_handlers (void);
224 static void create_file_handler (int fd
, int mask
, handler_func
*proc
,
225 gdb_client_data client_data
);
226 static int check_async_event_handlers (void);
227 static int gdb_wait_for_event (int);
228 static int update_wait_timeout (void);
229 static int poll_timers (void);
232 /* This event is signalled whenever an asynchronous handler needs to
233 defer an action to the event loop. */
234 static struct serial_event
*async_signal_handlers_serial_event
;
236 /* Callback registered with ASYNC_SIGNAL_HANDLERS_SERIAL_EVENT. */
239 async_signals_handler (int error
, gdb_client_data client_data
)
241 /* Do nothing. Handlers are run by invoke_async_signal_handlers
246 initialize_async_signal_handlers (void)
248 async_signal_handlers_serial_event
= make_serial_event ();
250 add_file_handler (serial_event_fd (async_signal_handlers_serial_event
),
251 async_signals_handler
, NULL
);
254 /* Process one high level event. If nothing is ready at this time,
255 wait for something to happen (via gdb_wait_for_event), then process
256 it. Returns >0 if something was done otherwise returns <0 (this
257 can happen if there are no event sources to wait for). */
260 gdb_do_one_event (void)
262 static int event_source_head
= 0;
263 const int number_of_sources
= 3;
266 /* First let's see if there are any asynchronous signal handlers
267 that are ready. These would be the result of invoking any of the
269 if (invoke_async_signal_handlers ())
272 /* To level the fairness across event sources, we poll them in a
273 round-robin fashion. */
274 for (current
= 0; current
< number_of_sources
; current
++)
278 switch (event_source_head
)
281 /* Are any timers that are ready? */
282 res
= poll_timers ();
285 /* Are there events already waiting to be collected on the
286 monitored file descriptors? */
287 res
= gdb_wait_for_event (0);
290 /* Are there any asynchronous event handlers ready? */
291 res
= check_async_event_handlers ();
294 internal_error (__FILE__
, __LINE__
,
295 "unexpected event_source_head %d",
300 if (event_source_head
== number_of_sources
)
301 event_source_head
= 0;
307 /* Block waiting for a new event. If gdb_wait_for_event returns -1,
308 we should get out because this means that there are no event
309 sources left. This will make the event loop stop, and the
312 if (gdb_wait_for_event (1) < 0)
315 /* If gdb_wait_for_event has returned 1, it means that one event has
316 been handled. We break out of the loop. */
322 /* Wrapper function for create_file_handler, so that the caller
323 doesn't have to know implementation details about the use of poll
326 add_file_handler (int fd
, handler_func
* proc
, gdb_client_data client_data
)
335 /* Check to see if poll () is usable. If not, we'll switch to
336 use select. This can happen on systems like
337 m68k-motorola-sys, `poll' cannot be used to wait for `stdin'.
338 On m68k-motorola-sysv, tty's are not stream-based and not
342 if (poll (&fds
, 1, 0) == 1 && (fds
.revents
& POLLNVAL
))
345 internal_error (__FILE__
, __LINE__
,
346 _("use_poll without HAVE_POLL"));
347 #endif /* HAVE_POLL */
352 create_file_handler (fd
, POLLIN
, proc
, client_data
);
354 internal_error (__FILE__
, __LINE__
,
355 _("use_poll without HAVE_POLL"));
359 create_file_handler (fd
, GDB_READABLE
| GDB_EXCEPTION
,
363 /* Add a file handler/descriptor to the list of descriptors we are
366 FD is the file descriptor for the file/stream to be listened to.
368 For the poll case, MASK is a combination (OR) of POLLIN,
369 POLLRDNORM, POLLRDBAND, POLLPRI, POLLOUT, POLLWRNORM, POLLWRBAND:
370 these are the events we are interested in. If any of them occurs,
371 proc should be called.
373 For the select case, MASK is a combination of READABLE, WRITABLE,
374 EXCEPTION. PROC is the procedure that will be called when an event
375 occurs for FD. CLIENT_DATA is the argument to pass to PROC. */
378 create_file_handler (int fd
, int mask
, handler_func
* proc
,
379 gdb_client_data client_data
)
381 file_handler
*file_ptr
;
383 /* Do we already have a file handler for this file? (We may be
384 changing its associated procedure). */
385 for (file_ptr
= gdb_notifier
.first_file_handler
; file_ptr
!= NULL
;
386 file_ptr
= file_ptr
->next_file
)
388 if (file_ptr
->fd
== fd
)
392 /* It is a new file descriptor. Add it to the list. Otherwise, just
393 change the data associated with it. */
394 if (file_ptr
== NULL
)
396 file_ptr
= XNEW (file_handler
);
398 file_ptr
->ready_mask
= 0;
399 file_ptr
->next_file
= gdb_notifier
.first_file_handler
;
400 gdb_notifier
.first_file_handler
= file_ptr
;
405 gdb_notifier
.num_fds
++;
406 if (gdb_notifier
.poll_fds
)
407 gdb_notifier
.poll_fds
=
408 (struct pollfd
*) xrealloc (gdb_notifier
.poll_fds
,
409 (gdb_notifier
.num_fds
410 * sizeof (struct pollfd
)));
412 gdb_notifier
.poll_fds
=
413 XNEW (struct pollfd
);
414 (gdb_notifier
.poll_fds
+ gdb_notifier
.num_fds
- 1)->fd
= fd
;
415 (gdb_notifier
.poll_fds
+ gdb_notifier
.num_fds
- 1)->events
= mask
;
416 (gdb_notifier
.poll_fds
+ gdb_notifier
.num_fds
- 1)->revents
= 0;
418 internal_error (__FILE__
, __LINE__
,
419 _("use_poll without HAVE_POLL"));
420 #endif /* HAVE_POLL */
424 if (mask
& GDB_READABLE
)
425 FD_SET (fd
, &gdb_notifier
.check_masks
[0]);
427 FD_CLR (fd
, &gdb_notifier
.check_masks
[0]);
429 if (mask
& GDB_WRITABLE
)
430 FD_SET (fd
, &gdb_notifier
.check_masks
[1]);
432 FD_CLR (fd
, &gdb_notifier
.check_masks
[1]);
434 if (mask
& GDB_EXCEPTION
)
435 FD_SET (fd
, &gdb_notifier
.check_masks
[2]);
437 FD_CLR (fd
, &gdb_notifier
.check_masks
[2]);
439 if (gdb_notifier
.num_fds
<= fd
)
440 gdb_notifier
.num_fds
= fd
+ 1;
444 file_ptr
->proc
= proc
;
445 file_ptr
->client_data
= client_data
;
446 file_ptr
->mask
= mask
;
449 /* Return the next file handler to handle, and advance to the next
450 file handler, wrapping around if the end of the list is
453 static file_handler
*
454 get_next_file_handler_to_handle_and_advance (void)
456 file_handler
*curr_next
;
458 /* The first time around, this is still NULL. */
459 if (gdb_notifier
.next_file_handler
== NULL
)
460 gdb_notifier
.next_file_handler
= gdb_notifier
.first_file_handler
;
462 curr_next
= gdb_notifier
.next_file_handler
;
463 gdb_assert (curr_next
!= NULL
);
466 gdb_notifier
.next_file_handler
= curr_next
->next_file
;
467 /* Wrap around, if necessary. */
468 if (gdb_notifier
.next_file_handler
== NULL
)
469 gdb_notifier
.next_file_handler
= gdb_notifier
.first_file_handler
;
474 /* Remove the file descriptor FD from the list of monitored fd's:
475 i.e. we don't care anymore about events on the FD. */
477 delete_file_handler (int fd
)
479 file_handler
*file_ptr
, *prev_ptr
= NULL
;
483 struct pollfd
*new_poll_fds
;
486 /* Find the entry for the given file. */
488 for (file_ptr
= gdb_notifier
.first_file_handler
; file_ptr
!= NULL
;
489 file_ptr
= file_ptr
->next_file
)
491 if (file_ptr
->fd
== fd
)
495 if (file_ptr
== NULL
)
501 /* Create a new poll_fds array by copying every fd's information
502 but the one we want to get rid of. */
504 new_poll_fds
= (struct pollfd
*)
505 xmalloc ((gdb_notifier
.num_fds
- 1) * sizeof (struct pollfd
));
507 for (i
= 0, j
= 0; i
< gdb_notifier
.num_fds
; i
++)
509 if ((gdb_notifier
.poll_fds
+ i
)->fd
!= fd
)
511 (new_poll_fds
+ j
)->fd
= (gdb_notifier
.poll_fds
+ i
)->fd
;
512 (new_poll_fds
+ j
)->events
= (gdb_notifier
.poll_fds
+ i
)->events
;
513 (new_poll_fds
+ j
)->revents
514 = (gdb_notifier
.poll_fds
+ i
)->revents
;
518 xfree (gdb_notifier
.poll_fds
);
519 gdb_notifier
.poll_fds
= new_poll_fds
;
520 gdb_notifier
.num_fds
--;
522 internal_error (__FILE__
, __LINE__
,
523 _("use_poll without HAVE_POLL"));
524 #endif /* HAVE_POLL */
528 if (file_ptr
->mask
& GDB_READABLE
)
529 FD_CLR (fd
, &gdb_notifier
.check_masks
[0]);
530 if (file_ptr
->mask
& GDB_WRITABLE
)
531 FD_CLR (fd
, &gdb_notifier
.check_masks
[1]);
532 if (file_ptr
->mask
& GDB_EXCEPTION
)
533 FD_CLR (fd
, &gdb_notifier
.check_masks
[2]);
535 /* Find current max fd. */
537 if ((fd
+ 1) == gdb_notifier
.num_fds
)
539 gdb_notifier
.num_fds
--;
540 for (i
= gdb_notifier
.num_fds
; i
; i
--)
542 if (FD_ISSET (i
- 1, &gdb_notifier
.check_masks
[0])
543 || FD_ISSET (i
- 1, &gdb_notifier
.check_masks
[1])
544 || FD_ISSET (i
- 1, &gdb_notifier
.check_masks
[2]))
547 gdb_notifier
.num_fds
= i
;
551 /* Deactivate the file descriptor, by clearing its mask,
552 so that it will not fire again. */
556 /* If this file handler was going to be the next one to be handled,
557 advance to the next's next, if any. */
558 if (gdb_notifier
.next_file_handler
== file_ptr
)
560 if (file_ptr
->next_file
== NULL
561 && file_ptr
== gdb_notifier
.first_file_handler
)
562 gdb_notifier
.next_file_handler
= NULL
;
564 get_next_file_handler_to_handle_and_advance ();
567 /* Get rid of the file handler in the file handler list. */
568 if (file_ptr
== gdb_notifier
.first_file_handler
)
569 gdb_notifier
.first_file_handler
= file_ptr
->next_file
;
572 for (prev_ptr
= gdb_notifier
.first_file_handler
;
573 prev_ptr
->next_file
!= file_ptr
;
574 prev_ptr
= prev_ptr
->next_file
)
576 prev_ptr
->next_file
= file_ptr
->next_file
;
581 /* Handle the given event by calling the procedure associated to the
582 corresponding file handler. */
585 handle_file_event (file_handler
*file_ptr
, int ready_mask
)
594 /* With poll, the ready_mask could have any of three events
595 set to 1: POLLHUP, POLLERR, POLLNVAL. These events
596 cannot be used in the requested event mask (events), but
597 they can be returned in the return mask (revents). We
598 need to check for those event too, and add them to the
599 mask which will be passed to the handler. */
601 /* See if the desired events (mask) match the received
602 events (ready_mask). */
607 /* POLLHUP means EOF, but can be combined with POLLIN to
608 signal more data to read. */
609 error_mask
= POLLHUP
| POLLERR
| POLLNVAL
;
610 mask
= ready_mask
& (file_ptr
->mask
| error_mask
);
612 if ((mask
& (POLLERR
| POLLNVAL
)) != 0)
614 /* Work in progress. We may need to tell somebody
615 what kind of error we had. */
617 printf_unfiltered (_("Error detected on fd %d\n"),
620 printf_unfiltered (_("Invalid or non-`poll'able fd %d\n"),
627 internal_error (__FILE__
, __LINE__
,
628 _("use_poll without HAVE_POLL"));
629 #endif /* HAVE_POLL */
633 if (ready_mask
& GDB_EXCEPTION
)
635 printf_unfiltered (_("Exception condition detected "
636 "on fd %d\n"), file_ptr
->fd
);
641 mask
= ready_mask
& file_ptr
->mask
;
644 /* If there was a match, then call the handler. */
646 (*file_ptr
->proc
) (file_ptr
->error
, file_ptr
->client_data
);
651 /* Wait for new events on the monitored file descriptors. Run the
652 event handler if the first descriptor that is detected by the poll.
653 If BLOCK and if there are no events, this function will block in
654 the call to poll. Return 1 if an event was handled. Return -1 if
655 there are no file descriptors to monitor. Return 1 if an event was
656 handled, otherwise returns 0. */
659 gdb_wait_for_event (int block
)
661 file_handler
*file_ptr
;
664 /* Make sure all output is done before getting another event. */
665 gdb_stdout
->flush ();
666 gdb_stderr
->flush ();
668 if (gdb_notifier
.num_fds
== 0)
672 update_wait_timeout ();
680 timeout
= gdb_notifier
.timeout_valid
? gdb_notifier
.poll_timeout
: -1;
684 num_found
= poll (gdb_notifier
.poll_fds
,
685 (unsigned long) gdb_notifier
.num_fds
, timeout
);
687 /* Don't print anything if we get out of poll because of a
689 if (num_found
== -1 && errno
!= EINTR
)
690 perror_with_name (("poll"));
692 internal_error (__FILE__
, __LINE__
,
693 _("use_poll without HAVE_POLL"));
694 #endif /* HAVE_POLL */
698 struct timeval select_timeout
;
699 struct timeval
*timeout_p
;
702 timeout_p
= gdb_notifier
.timeout_valid
703 ? &gdb_notifier
.select_timeout
: NULL
;
706 memset (&select_timeout
, 0, sizeof (select_timeout
));
707 timeout_p
= &select_timeout
;
710 gdb_notifier
.ready_masks
[0] = gdb_notifier
.check_masks
[0];
711 gdb_notifier
.ready_masks
[1] = gdb_notifier
.check_masks
[1];
712 gdb_notifier
.ready_masks
[2] = gdb_notifier
.check_masks
[2];
713 num_found
= gdb_select (gdb_notifier
.num_fds
,
714 &gdb_notifier
.ready_masks
[0],
715 &gdb_notifier
.ready_masks
[1],
716 &gdb_notifier
.ready_masks
[2],
719 /* Clear the masks after an error from select. */
722 FD_ZERO (&gdb_notifier
.ready_masks
[0]);
723 FD_ZERO (&gdb_notifier
.ready_masks
[1]);
724 FD_ZERO (&gdb_notifier
.ready_masks
[2]);
726 /* Dont print anything if we got a signal, let gdb handle
729 perror_with_name (("select"));
733 /* Avoid looking at poll_fds[i]->revents if no event fired. */
737 /* Run event handlers. We always run just one handler and go back
738 to polling, in case a handler changes the notifier list. Since
739 events for sources we haven't consumed yet wake poll/select
740 immediately, no event is lost. */
742 /* To level the fairness across event descriptors, we handle them in
743 a round-robin-like fashion. The number and order of descriptors
744 may change between invocations, but this is good enough. */
753 if (gdb_notifier
.next_poll_fds_index
>= gdb_notifier
.num_fds
)
754 gdb_notifier
.next_poll_fds_index
= 0;
755 i
= gdb_notifier
.next_poll_fds_index
++;
757 gdb_assert (i
< gdb_notifier
.num_fds
);
758 if ((gdb_notifier
.poll_fds
+ i
)->revents
)
762 for (file_ptr
= gdb_notifier
.first_file_handler
;
764 file_ptr
= file_ptr
->next_file
)
766 if (file_ptr
->fd
== (gdb_notifier
.poll_fds
+ i
)->fd
)
769 gdb_assert (file_ptr
!= NULL
);
771 mask
= (gdb_notifier
.poll_fds
+ i
)->revents
;
772 handle_file_event (file_ptr
, mask
);
775 internal_error (__FILE__
, __LINE__
,
776 _("use_poll without HAVE_POLL"));
777 #endif /* HAVE_POLL */
781 /* See comment about even source fairness above. */
786 file_ptr
= get_next_file_handler_to_handle_and_advance ();
788 if (FD_ISSET (file_ptr
->fd
, &gdb_notifier
.ready_masks
[0]))
789 mask
|= GDB_READABLE
;
790 if (FD_ISSET (file_ptr
->fd
, &gdb_notifier
.ready_masks
[1]))
791 mask
|= GDB_WRITABLE
;
792 if (FD_ISSET (file_ptr
->fd
, &gdb_notifier
.ready_masks
[2]))
793 mask
|= GDB_EXCEPTION
;
797 handle_file_event (file_ptr
, mask
);
804 /* Create an asynchronous handler, allocating memory for it.
805 Return a pointer to the newly created handler.
806 This pointer will be used to invoke the handler by
807 invoke_async_signal_handler.
808 PROC is the function to call with CLIENT_DATA argument
809 whenever the handler is invoked. */
810 async_signal_handler
*
811 create_async_signal_handler (sig_handler_func
* proc
,
812 gdb_client_data client_data
)
814 async_signal_handler
*async_handler_ptr
;
816 async_handler_ptr
= XNEW (async_signal_handler
);
817 async_handler_ptr
->ready
= 0;
818 async_handler_ptr
->next_handler
= NULL
;
819 async_handler_ptr
->proc
= proc
;
820 async_handler_ptr
->client_data
= client_data
;
821 if (sighandler_list
.first_handler
== NULL
)
822 sighandler_list
.first_handler
= async_handler_ptr
;
824 sighandler_list
.last_handler
->next_handler
= async_handler_ptr
;
825 sighandler_list
.last_handler
= async_handler_ptr
;
826 return async_handler_ptr
;
829 /* Mark the handler (ASYNC_HANDLER_PTR) as ready. This information
830 will be used when the handlers are invoked, after we have waited
831 for some event. The caller of this function is the interrupt
832 handler associated with a signal. */
834 mark_async_signal_handler (async_signal_handler
* async_handler_ptr
)
836 async_handler_ptr
->ready
= 1;
837 serial_event_set (async_signal_handlers_serial_event
);
840 /* See event-loop.h. */
843 clear_async_signal_handler (async_signal_handler
*async_handler_ptr
)
845 async_handler_ptr
->ready
= 0;
848 /* See event-loop.h. */
851 async_signal_handler_is_marked (async_signal_handler
*async_handler_ptr
)
853 return async_handler_ptr
->ready
;
856 /* Call all the handlers that are ready. Returns true if any was
860 invoke_async_signal_handlers (void)
862 async_signal_handler
*async_handler_ptr
;
865 /* We're going to handle all pending signals, so no need to wake up
866 the event loop again the next time around. Note this must be
867 cleared _before_ calling the callbacks, to avoid races. */
868 serial_event_clear (async_signal_handlers_serial_event
);
870 /* Invoke all ready handlers. */
874 for (async_handler_ptr
= sighandler_list
.first_handler
;
875 async_handler_ptr
!= NULL
;
876 async_handler_ptr
= async_handler_ptr
->next_handler
)
878 if (async_handler_ptr
->ready
)
881 if (async_handler_ptr
== NULL
)
884 async_handler_ptr
->ready
= 0;
885 /* Async signal handlers have no connection to whichever was the
886 current UI, and thus always run on the main one. */
887 current_ui
= main_ui
;
888 (*async_handler_ptr
->proc
) (async_handler_ptr
->client_data
);
894 /* Delete an asynchronous handler (ASYNC_HANDLER_PTR).
895 Free the space allocated for it. */
897 delete_async_signal_handler (async_signal_handler
** async_handler_ptr
)
899 async_signal_handler
*prev_ptr
;
901 if (sighandler_list
.first_handler
== (*async_handler_ptr
))
903 sighandler_list
.first_handler
= (*async_handler_ptr
)->next_handler
;
904 if (sighandler_list
.first_handler
== NULL
)
905 sighandler_list
.last_handler
= NULL
;
909 prev_ptr
= sighandler_list
.first_handler
;
910 while (prev_ptr
&& prev_ptr
->next_handler
!= (*async_handler_ptr
))
911 prev_ptr
= prev_ptr
->next_handler
;
912 gdb_assert (prev_ptr
);
913 prev_ptr
->next_handler
= (*async_handler_ptr
)->next_handler
;
914 if (sighandler_list
.last_handler
== (*async_handler_ptr
))
915 sighandler_list
.last_handler
= prev_ptr
;
917 xfree ((*async_handler_ptr
));
918 (*async_handler_ptr
) = NULL
;
921 /* Create an asynchronous event handler, allocating memory for it.
922 Return a pointer to the newly created handler. PROC is the
923 function to call with CLIENT_DATA argument whenever the handler is
925 async_event_handler
*
926 create_async_event_handler (async_event_handler_func
*proc
,
927 gdb_client_data client_data
)
929 async_event_handler
*h
;
931 h
= XNEW (struct async_event_handler
);
933 h
->next_handler
= NULL
;
935 h
->client_data
= client_data
;
936 if (async_event_handler_list
.first_handler
== NULL
)
937 async_event_handler_list
.first_handler
= h
;
939 async_event_handler_list
.last_handler
->next_handler
= h
;
940 async_event_handler_list
.last_handler
= h
;
944 /* Mark the handler (ASYNC_HANDLER_PTR) as ready. This information
945 will be used by gdb_do_one_event. The caller will be whoever
946 created the event source, and wants to signal that the event is
947 ready to be handled. */
949 mark_async_event_handler (async_event_handler
*async_handler_ptr
)
951 async_handler_ptr
->ready
= 1;
954 /* See event-loop.h. */
957 clear_async_event_handler (async_event_handler
*async_handler_ptr
)
959 async_handler_ptr
->ready
= 0;
962 /* Check if asynchronous event handlers are ready, and call the
963 handler function for one that is. */
966 check_async_event_handlers (void)
968 async_event_handler
*async_handler_ptr
;
970 for (async_handler_ptr
= async_event_handler_list
.first_handler
;
971 async_handler_ptr
!= NULL
;
972 async_handler_ptr
= async_handler_ptr
->next_handler
)
974 if (async_handler_ptr
->ready
)
976 async_handler_ptr
->ready
= 0;
977 (*async_handler_ptr
->proc
) (async_handler_ptr
->client_data
);
985 /* Delete an asynchronous handler (ASYNC_HANDLER_PTR).
986 Free the space allocated for it. */
988 delete_async_event_handler (async_event_handler
**async_handler_ptr
)
990 async_event_handler
*prev_ptr
;
992 if (async_event_handler_list
.first_handler
== *async_handler_ptr
)
994 async_event_handler_list
.first_handler
995 = (*async_handler_ptr
)->next_handler
;
996 if (async_event_handler_list
.first_handler
== NULL
)
997 async_event_handler_list
.last_handler
= NULL
;
1001 prev_ptr
= async_event_handler_list
.first_handler
;
1002 while (prev_ptr
&& prev_ptr
->next_handler
!= *async_handler_ptr
)
1003 prev_ptr
= prev_ptr
->next_handler
;
1004 gdb_assert (prev_ptr
);
1005 prev_ptr
->next_handler
= (*async_handler_ptr
)->next_handler
;
1006 if (async_event_handler_list
.last_handler
== (*async_handler_ptr
))
1007 async_event_handler_list
.last_handler
= prev_ptr
;
1009 xfree (*async_handler_ptr
);
1010 *async_handler_ptr
= NULL
;
1013 /* Create a timer that will expire in MS milliseconds from now. When
1014 the timer is ready, PROC will be executed. At creation, the timer
1015 is added to the timers queue. This queue is kept sorted in order
1016 of increasing timers. Return a handle to the timer struct. */
1019 create_timer (int ms
, timer_handler_func
*proc
,
1020 gdb_client_data client_data
)
1022 using namespace std::chrono
;
1023 struct gdb_timer
*timer_ptr
, *timer_index
, *prev_timer
;
1025 steady_clock::time_point time_now
= steady_clock::now ();
1027 timer_ptr
= new gdb_timer ();
1028 timer_ptr
->when
= time_now
+ milliseconds (ms
);
1029 timer_ptr
->proc
= proc
;
1030 timer_ptr
->client_data
= client_data
;
1031 timer_list
.num_timers
++;
1032 timer_ptr
->timer_id
= timer_list
.num_timers
;
1034 /* Now add the timer to the timer queue, making sure it is sorted in
1035 increasing order of expiration. */
1037 for (timer_index
= timer_list
.first_timer
;
1038 timer_index
!= NULL
;
1039 timer_index
= timer_index
->next
)
1041 if (timer_index
->when
> timer_ptr
->when
)
1045 if (timer_index
== timer_list
.first_timer
)
1047 timer_ptr
->next
= timer_list
.first_timer
;
1048 timer_list
.first_timer
= timer_ptr
;
1053 for (prev_timer
= timer_list
.first_timer
;
1054 prev_timer
->next
!= timer_index
;
1055 prev_timer
= prev_timer
->next
)
1058 prev_timer
->next
= timer_ptr
;
1059 timer_ptr
->next
= timer_index
;
1062 gdb_notifier
.timeout_valid
= 0;
1063 return timer_ptr
->timer_id
;
1066 /* There is a chance that the creator of the timer wants to get rid of
1067 it before it expires. */
1069 delete_timer (int id
)
1071 struct gdb_timer
*timer_ptr
, *prev_timer
= NULL
;
1073 /* Find the entry for the given timer. */
1075 for (timer_ptr
= timer_list
.first_timer
; timer_ptr
!= NULL
;
1076 timer_ptr
= timer_ptr
->next
)
1078 if (timer_ptr
->timer_id
== id
)
1082 if (timer_ptr
== NULL
)
1084 /* Get rid of the timer in the timer list. */
1085 if (timer_ptr
== timer_list
.first_timer
)
1086 timer_list
.first_timer
= timer_ptr
->next
;
1089 for (prev_timer
= timer_list
.first_timer
;
1090 prev_timer
->next
!= timer_ptr
;
1091 prev_timer
= prev_timer
->next
)
1093 prev_timer
->next
= timer_ptr
->next
;
1097 gdb_notifier
.timeout_valid
= 0;
1100 /* Convert a std::chrono duration to a struct timeval. */
1102 template<typename Duration
>
1103 static struct timeval
1104 duration_cast_timeval (const Duration
&d
)
1106 using namespace std::chrono
;
1107 seconds sec
= duration_cast
<seconds
> (d
);
1108 microseconds msec
= duration_cast
<microseconds
> (d
- sec
);
1111 tv
.tv_sec
= sec
.count ();
1112 tv
.tv_usec
= msec
.count ();
1116 /* Update the timeout for the select() or poll(). Returns true if the
1117 timer has already expired, false otherwise. */
1120 update_wait_timeout (void)
1122 if (timer_list
.first_timer
!= NULL
)
1124 using namespace std::chrono
;
1125 steady_clock::time_point time_now
= steady_clock::now ();
1126 struct timeval timeout
;
1128 if (timer_list
.first_timer
->when
< time_now
)
1130 /* It expired already. */
1132 timeout
.tv_usec
= 0;
1136 steady_clock::duration d
= timer_list
.first_timer
->when
- time_now
;
1137 timeout
= duration_cast_timeval (d
);
1140 /* Update the timeout for select/ poll. */
1144 gdb_notifier
.poll_timeout
= timeout
.tv_sec
* 1000;
1146 internal_error (__FILE__
, __LINE__
,
1147 _("use_poll without HAVE_POLL"));
1148 #endif /* HAVE_POLL */
1152 gdb_notifier
.select_timeout
.tv_sec
= timeout
.tv_sec
;
1153 gdb_notifier
.select_timeout
.tv_usec
= timeout
.tv_usec
;
1155 gdb_notifier
.timeout_valid
= 1;
1157 if (timer_list
.first_timer
->when
< time_now
)
1161 gdb_notifier
.timeout_valid
= 0;
1166 /* Check whether a timer in the timers queue is ready. If a timer is
1167 ready, call its handler and return. Update the timeout for the
1168 select() or poll() as well. Return 1 if an event was handled,
1169 otherwise returns 0.*/
1174 if (update_wait_timeout ())
1176 struct gdb_timer
*timer_ptr
= timer_list
.first_timer
;
1177 timer_handler_func
*proc
= timer_ptr
->proc
;
1178 gdb_client_data client_data
= timer_ptr
->client_data
;
1180 /* Get rid of the timer from the beginning of the list. */
1181 timer_list
.first_timer
= timer_ptr
->next
;
1183 /* Delete the timer before calling the callback, not after, in
1184 case the callback itself decides to try deleting the timer
1188 /* Call the procedure associated with that timer. */
1189 (proc
) (client_data
);