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"
28 #if defined (HAVE_POLL_H)
30 #elif defined (HAVE_SYS_POLL_H)
35 #include <sys/types.h>
36 #include "gdbsupport/gdb_sys_time.h"
37 #include "gdbsupport/gdb_select.h"
40 /* Tell create_file_handler what events we are interested in.
41 This is used by the select version of the event loop. */
43 #define GDB_READABLE (1<<1)
44 #define GDB_WRITABLE (1<<2)
45 #define GDB_EXCEPTION (1<<3)
47 /* Information about each file descriptor we register with the event
50 typedef struct file_handler
52 int fd
; /* File descriptor. */
53 int mask
; /* Events we want to monitor: POLLIN, etc. */
54 int ready_mask
; /* Events that have been seen since
56 handler_func
*proc
; /* Procedure to call when fd is ready. */
57 gdb_client_data client_data
; /* Argument to pass to proc. */
58 int error
; /* Was an error detected on this fd? */
59 struct file_handler
*next_file
; /* Next registered file descriptor. */
63 /* PROC is a function to be invoked when the READY flag is set. This
64 happens when there has been a signal and the corresponding signal
65 handler has 'triggered' this async_signal_handler for execution.
66 The actual work to be done in response to a signal will be carried
67 out by PROC at a later time, within process_event. This provides a
68 deferred execution of signal handlers.
70 Async_init_signals takes care of setting up such an
71 async_signal_handler for each interesting signal. */
73 typedef struct async_signal_handler
75 int ready
; /* If ready, call this handler
76 from the main event loop, using
77 invoke_async_handler. */
78 struct async_signal_handler
*next_handler
; /* Ptr to next handler. */
79 sig_handler_func
*proc
; /* Function to call to do the work. */
80 gdb_client_data client_data
; /* Argument to async_handler_func. */
84 /* PROC is a function to be invoked when the READY flag is set. This
85 happens when the event has been marked with
86 MARK_ASYNC_EVENT_HANDLER. The actual work to be done in response
87 to an event will be carried out by PROC at a later time, within
88 process_event. This provides a deferred execution of event
90 typedef struct async_event_handler
92 /* If ready, call this handler from the main event loop, using
93 invoke_event_handler. */
96 /* Point to next handler. */
97 struct async_event_handler
*next_handler
;
99 /* Function to call to do the work. */
100 async_event_handler_func
*proc
;
102 /* Argument to PROC. */
103 gdb_client_data client_data
;
107 /* Gdb_notifier is just a list of file descriptors gdb is interested in.
108 These are the input file descriptor, and the target file
109 descriptor. We have two flavors of the notifier, one for platforms
110 that have the POLL function, the other for those that don't, and
111 only support SELECT. Each of the elements in the gdb_notifier list is
112 basically a description of what kind of events gdb is interested
115 /* As of 1999-04-30 only the input file descriptor is registered with the
118 /* Do we use poll or select ? */
123 #endif /* HAVE_POLL */
125 static unsigned char use_poll
= USE_POLL
;
134 /* Ptr to head of file handler list. */
135 file_handler
*first_file_handler
;
137 /* Next file handler to handle, for the select variant. To level
138 the fairness across event sources, we serve file handlers in a
139 round-robin-like fashion. The number and order of the polled
140 file handlers may change between invocations, but this is good
142 file_handler
*next_file_handler
;
145 /* Ptr to array of pollfd structures. */
146 struct pollfd
*poll_fds
;
148 /* Next file descriptor to handle, for the poll variant. To level
149 the fairness across event sources, we poll the file descriptors
150 in a round-robin-like fashion. The number and order of the
151 polled file descriptors may change between invocations, but
152 this is good enough. */
153 int next_poll_fds_index
;
155 /* Timeout in milliseconds for calls to poll(). */
159 /* Masks to be used in the next call to select.
160 Bits are set in response to calls to create_file_handler. */
161 fd_set check_masks
[3];
163 /* What file descriptors were found ready by select. */
164 fd_set ready_masks
[3];
166 /* Number of file descriptors to monitor (for poll). */
167 /* Number of valid bits (highest fd value + 1) (for select). */
170 /* Time structure for calls to select(). */
171 struct timeval select_timeout
;
173 /* Flag to tell whether the timeout should be used. */
178 /* Structure associated with a timer. PROC will be executed at the
179 first occasion after WHEN. */
182 std::chrono::steady_clock::time_point when
;
184 struct gdb_timer
*next
;
185 timer_handler_func
*proc
; /* Function to call to do the work. */
186 gdb_client_data client_data
; /* Argument to async_handler_func. */
189 /* List of currently active timers. It is sorted in order of
190 increasing timers. */
193 /* Pointer to first in timer list. */
194 struct gdb_timer
*first_timer
;
196 /* Id of the last timer created. */
201 /* All the async_signal_handlers gdb is interested in are kept onto
205 /* Pointer to first in handler list. */
206 async_signal_handler
*first_handler
;
208 /* Pointer to last in handler list. */
209 async_signal_handler
*last_handler
;
213 /* All the async_event_handlers gdb is interested in are kept onto
217 /* Pointer to first in handler list. */
218 async_event_handler
*first_handler
;
220 /* Pointer to last in handler list. */
221 async_event_handler
*last_handler
;
223 async_event_handler_list
;
225 static int invoke_async_signal_handlers (void);
226 static void create_file_handler (int fd
, int mask
, handler_func
*proc
,
227 gdb_client_data client_data
);
228 static int check_async_event_handlers (void);
229 static int gdb_wait_for_event (int);
230 static int update_wait_timeout (void);
231 static int poll_timers (void);
234 /* This event is signalled whenever an asynchronous handler needs to
235 defer an action to the event loop. */
236 static struct serial_event
*async_signal_handlers_serial_event
;
238 /* Callback registered with ASYNC_SIGNAL_HANDLERS_SERIAL_EVENT. */
241 async_signals_handler (int error
, gdb_client_data client_data
)
243 /* Do nothing. Handlers are run by invoke_async_signal_handlers
248 initialize_async_signal_handlers (void)
250 async_signal_handlers_serial_event
= make_serial_event ();
252 add_file_handler (serial_event_fd (async_signal_handlers_serial_event
),
253 async_signals_handler
, NULL
);
256 /* Process one high level event. If nothing is ready at this time,
257 wait for something to happen (via gdb_wait_for_event), then process
258 it. Returns >0 if something was done otherwise returns <0 (this
259 can happen if there are no event sources to wait for). */
262 gdb_do_one_event (void)
264 static int event_source_head
= 0;
265 const int number_of_sources
= 3;
268 /* First let's see if there are any asynchronous signal handlers
269 that are ready. These would be the result of invoking any of the
271 if (invoke_async_signal_handlers ())
274 /* To level the fairness across event sources, we poll them in a
275 round-robin fashion. */
276 for (current
= 0; current
< number_of_sources
; current
++)
280 switch (event_source_head
)
283 /* Are any timers that are ready? */
284 res
= poll_timers ();
287 /* Are there events already waiting to be collected on the
288 monitored file descriptors? */
289 res
= gdb_wait_for_event (0);
292 /* Are there any asynchronous event handlers ready? */
293 res
= check_async_event_handlers ();
296 internal_error (__FILE__
, __LINE__
,
297 "unexpected event_source_head %d",
302 if (event_source_head
== number_of_sources
)
303 event_source_head
= 0;
309 /* Block waiting for a new event. If gdb_wait_for_event returns -1,
310 we should get out because this means that there are no event
311 sources left. This will make the event loop stop, and the
314 if (gdb_wait_for_event (1) < 0)
317 /* If gdb_wait_for_event has returned 1, it means that one event has
318 been handled. We break out of the loop. */
324 /* Wrapper function for create_file_handler, so that the caller
325 doesn't have to know implementation details about the use of poll
328 add_file_handler (int fd
, handler_func
* proc
, gdb_client_data client_data
)
337 /* Check to see if poll () is usable. If not, we'll switch to
338 use select. This can happen on systems like
339 m68k-motorola-sys, `poll' cannot be used to wait for `stdin'.
340 On m68k-motorola-sysv, tty's are not stream-based and not
344 if (poll (&fds
, 1, 0) == 1 && (fds
.revents
& POLLNVAL
))
347 internal_error (__FILE__
, __LINE__
,
348 _("use_poll without HAVE_POLL"));
349 #endif /* HAVE_POLL */
354 create_file_handler (fd
, POLLIN
, proc
, client_data
);
356 internal_error (__FILE__
, __LINE__
,
357 _("use_poll without HAVE_POLL"));
361 create_file_handler (fd
, GDB_READABLE
| GDB_EXCEPTION
,
365 /* Add a file handler/descriptor to the list of descriptors we are
368 FD is the file descriptor for the file/stream to be listened to.
370 For the poll case, MASK is a combination (OR) of POLLIN,
371 POLLRDNORM, POLLRDBAND, POLLPRI, POLLOUT, POLLWRNORM, POLLWRBAND:
372 these are the events we are interested in. If any of them occurs,
373 proc should be called.
375 For the select case, MASK is a combination of READABLE, WRITABLE,
376 EXCEPTION. PROC is the procedure that will be called when an event
377 occurs for FD. CLIENT_DATA is the argument to pass to PROC. */
380 create_file_handler (int fd
, int mask
, handler_func
* proc
,
381 gdb_client_data client_data
)
383 file_handler
*file_ptr
;
385 /* Do we already have a file handler for this file? (We may be
386 changing its associated procedure). */
387 for (file_ptr
= gdb_notifier
.first_file_handler
; file_ptr
!= NULL
;
388 file_ptr
= file_ptr
->next_file
)
390 if (file_ptr
->fd
== fd
)
394 /* It is a new file descriptor. Add it to the list. Otherwise, just
395 change the data associated with it. */
396 if (file_ptr
== NULL
)
398 file_ptr
= XNEW (file_handler
);
400 file_ptr
->ready_mask
= 0;
401 file_ptr
->next_file
= gdb_notifier
.first_file_handler
;
402 gdb_notifier
.first_file_handler
= file_ptr
;
407 gdb_notifier
.num_fds
++;
408 if (gdb_notifier
.poll_fds
)
409 gdb_notifier
.poll_fds
=
410 (struct pollfd
*) xrealloc (gdb_notifier
.poll_fds
,
411 (gdb_notifier
.num_fds
412 * sizeof (struct pollfd
)));
414 gdb_notifier
.poll_fds
=
415 XNEW (struct pollfd
);
416 (gdb_notifier
.poll_fds
+ gdb_notifier
.num_fds
- 1)->fd
= fd
;
417 (gdb_notifier
.poll_fds
+ gdb_notifier
.num_fds
- 1)->events
= mask
;
418 (gdb_notifier
.poll_fds
+ gdb_notifier
.num_fds
- 1)->revents
= 0;
420 internal_error (__FILE__
, __LINE__
,
421 _("use_poll without HAVE_POLL"));
422 #endif /* HAVE_POLL */
426 if (mask
& GDB_READABLE
)
427 FD_SET (fd
, &gdb_notifier
.check_masks
[0]);
429 FD_CLR (fd
, &gdb_notifier
.check_masks
[0]);
431 if (mask
& GDB_WRITABLE
)
432 FD_SET (fd
, &gdb_notifier
.check_masks
[1]);
434 FD_CLR (fd
, &gdb_notifier
.check_masks
[1]);
436 if (mask
& GDB_EXCEPTION
)
437 FD_SET (fd
, &gdb_notifier
.check_masks
[2]);
439 FD_CLR (fd
, &gdb_notifier
.check_masks
[2]);
441 if (gdb_notifier
.num_fds
<= fd
)
442 gdb_notifier
.num_fds
= fd
+ 1;
446 file_ptr
->proc
= proc
;
447 file_ptr
->client_data
= client_data
;
448 file_ptr
->mask
= mask
;
451 /* Return the next file handler to handle, and advance to the next
452 file handler, wrapping around if the end of the list is
455 static file_handler
*
456 get_next_file_handler_to_handle_and_advance (void)
458 file_handler
*curr_next
;
460 /* The first time around, this is still NULL. */
461 if (gdb_notifier
.next_file_handler
== NULL
)
462 gdb_notifier
.next_file_handler
= gdb_notifier
.first_file_handler
;
464 curr_next
= gdb_notifier
.next_file_handler
;
465 gdb_assert (curr_next
!= NULL
);
468 gdb_notifier
.next_file_handler
= curr_next
->next_file
;
469 /* Wrap around, if necessary. */
470 if (gdb_notifier
.next_file_handler
== NULL
)
471 gdb_notifier
.next_file_handler
= gdb_notifier
.first_file_handler
;
476 /* Remove the file descriptor FD from the list of monitored fd's:
477 i.e. we don't care anymore about events on the FD. */
479 delete_file_handler (int fd
)
481 file_handler
*file_ptr
, *prev_ptr
= NULL
;
485 struct pollfd
*new_poll_fds
;
488 /* Find the entry for the given file. */
490 for (file_ptr
= gdb_notifier
.first_file_handler
; file_ptr
!= NULL
;
491 file_ptr
= file_ptr
->next_file
)
493 if (file_ptr
->fd
== fd
)
497 if (file_ptr
== NULL
)
503 /* Create a new poll_fds array by copying every fd's information
504 but the one we want to get rid of. */
506 new_poll_fds
= (struct pollfd
*)
507 xmalloc ((gdb_notifier
.num_fds
- 1) * sizeof (struct pollfd
));
509 for (i
= 0, j
= 0; i
< gdb_notifier
.num_fds
; i
++)
511 if ((gdb_notifier
.poll_fds
+ i
)->fd
!= fd
)
513 (new_poll_fds
+ j
)->fd
= (gdb_notifier
.poll_fds
+ i
)->fd
;
514 (new_poll_fds
+ j
)->events
= (gdb_notifier
.poll_fds
+ i
)->events
;
515 (new_poll_fds
+ j
)->revents
516 = (gdb_notifier
.poll_fds
+ i
)->revents
;
520 xfree (gdb_notifier
.poll_fds
);
521 gdb_notifier
.poll_fds
= new_poll_fds
;
522 gdb_notifier
.num_fds
--;
524 internal_error (__FILE__
, __LINE__
,
525 _("use_poll without HAVE_POLL"));
526 #endif /* HAVE_POLL */
530 if (file_ptr
->mask
& GDB_READABLE
)
531 FD_CLR (fd
, &gdb_notifier
.check_masks
[0]);
532 if (file_ptr
->mask
& GDB_WRITABLE
)
533 FD_CLR (fd
, &gdb_notifier
.check_masks
[1]);
534 if (file_ptr
->mask
& GDB_EXCEPTION
)
535 FD_CLR (fd
, &gdb_notifier
.check_masks
[2]);
537 /* Find current max fd. */
539 if ((fd
+ 1) == gdb_notifier
.num_fds
)
541 gdb_notifier
.num_fds
--;
542 for (i
= gdb_notifier
.num_fds
; i
; i
--)
544 if (FD_ISSET (i
- 1, &gdb_notifier
.check_masks
[0])
545 || FD_ISSET (i
- 1, &gdb_notifier
.check_masks
[1])
546 || FD_ISSET (i
- 1, &gdb_notifier
.check_masks
[2]))
549 gdb_notifier
.num_fds
= i
;
553 /* Deactivate the file descriptor, by clearing its mask,
554 so that it will not fire again. */
558 /* If this file handler was going to be the next one to be handled,
559 advance to the next's next, if any. */
560 if (gdb_notifier
.next_file_handler
== file_ptr
)
562 if (file_ptr
->next_file
== NULL
563 && file_ptr
== gdb_notifier
.first_file_handler
)
564 gdb_notifier
.next_file_handler
= NULL
;
566 get_next_file_handler_to_handle_and_advance ();
569 /* Get rid of the file handler in the file handler list. */
570 if (file_ptr
== gdb_notifier
.first_file_handler
)
571 gdb_notifier
.first_file_handler
= file_ptr
->next_file
;
574 for (prev_ptr
= gdb_notifier
.first_file_handler
;
575 prev_ptr
->next_file
!= file_ptr
;
576 prev_ptr
= prev_ptr
->next_file
)
578 prev_ptr
->next_file
= file_ptr
->next_file
;
583 /* Handle the given event by calling the procedure associated to the
584 corresponding file handler. */
587 handle_file_event (file_handler
*file_ptr
, int ready_mask
)
596 /* With poll, the ready_mask could have any of three events
597 set to 1: POLLHUP, POLLERR, POLLNVAL. These events
598 cannot be used in the requested event mask (events), but
599 they can be returned in the return mask (revents). We
600 need to check for those event too, and add them to the
601 mask which will be passed to the handler. */
603 /* See if the desired events (mask) match the received
604 events (ready_mask). */
609 /* POLLHUP means EOF, but can be combined with POLLIN to
610 signal more data to read. */
611 error_mask
= POLLHUP
| POLLERR
| POLLNVAL
;
612 mask
= ready_mask
& (file_ptr
->mask
| error_mask
);
614 if ((mask
& (POLLERR
| POLLNVAL
)) != 0)
616 /* Work in progress. We may need to tell somebody
617 what kind of error we had. */
619 printf_unfiltered (_("Error detected on fd %d\n"),
622 printf_unfiltered (_("Invalid or non-`poll'able fd %d\n"),
629 internal_error (__FILE__
, __LINE__
,
630 _("use_poll without HAVE_POLL"));
631 #endif /* HAVE_POLL */
635 if (ready_mask
& GDB_EXCEPTION
)
637 printf_unfiltered (_("Exception condition detected "
638 "on fd %d\n"), file_ptr
->fd
);
643 mask
= ready_mask
& file_ptr
->mask
;
646 /* If there was a match, then call the handler. */
648 (*file_ptr
->proc
) (file_ptr
->error
, file_ptr
->client_data
);
653 /* Wait for new events on the monitored file descriptors. Run the
654 event handler if the first descriptor that is detected by the poll.
655 If BLOCK and if there are no events, this function will block in
656 the call to poll. Return 1 if an event was handled. Return -1 if
657 there are no file descriptors to monitor. Return 1 if an event was
658 handled, otherwise returns 0. */
661 gdb_wait_for_event (int block
)
663 file_handler
*file_ptr
;
666 /* Make sure all output is done before getting another event. */
667 gdb_stdout
->flush ();
668 gdb_stderr
->flush ();
670 if (gdb_notifier
.num_fds
== 0)
674 update_wait_timeout ();
682 timeout
= gdb_notifier
.timeout_valid
? gdb_notifier
.poll_timeout
: -1;
686 num_found
= poll (gdb_notifier
.poll_fds
,
687 (unsigned long) gdb_notifier
.num_fds
, timeout
);
689 /* Don't print anything if we get out of poll because of a
691 if (num_found
== -1 && errno
!= EINTR
)
692 perror_with_name (("poll"));
694 internal_error (__FILE__
, __LINE__
,
695 _("use_poll without HAVE_POLL"));
696 #endif /* HAVE_POLL */
700 struct timeval select_timeout
;
701 struct timeval
*timeout_p
;
704 timeout_p
= gdb_notifier
.timeout_valid
705 ? &gdb_notifier
.select_timeout
: NULL
;
708 memset (&select_timeout
, 0, sizeof (select_timeout
));
709 timeout_p
= &select_timeout
;
712 gdb_notifier
.ready_masks
[0] = gdb_notifier
.check_masks
[0];
713 gdb_notifier
.ready_masks
[1] = gdb_notifier
.check_masks
[1];
714 gdb_notifier
.ready_masks
[2] = gdb_notifier
.check_masks
[2];
715 num_found
= gdb_select (gdb_notifier
.num_fds
,
716 &gdb_notifier
.ready_masks
[0],
717 &gdb_notifier
.ready_masks
[1],
718 &gdb_notifier
.ready_masks
[2],
721 /* Clear the masks after an error from select. */
724 FD_ZERO (&gdb_notifier
.ready_masks
[0]);
725 FD_ZERO (&gdb_notifier
.ready_masks
[1]);
726 FD_ZERO (&gdb_notifier
.ready_masks
[2]);
728 /* Dont print anything if we got a signal, let gdb handle
731 perror_with_name (("select"));
735 /* Avoid looking at poll_fds[i]->revents if no event fired. */
739 /* Run event handlers. We always run just one handler and go back
740 to polling, in case a handler changes the notifier list. Since
741 events for sources we haven't consumed yet wake poll/select
742 immediately, no event is lost. */
744 /* To level the fairness across event descriptors, we handle them in
745 a round-robin-like fashion. The number and order of descriptors
746 may change between invocations, but this is good enough. */
755 if (gdb_notifier
.next_poll_fds_index
>= gdb_notifier
.num_fds
)
756 gdb_notifier
.next_poll_fds_index
= 0;
757 i
= gdb_notifier
.next_poll_fds_index
++;
759 gdb_assert (i
< gdb_notifier
.num_fds
);
760 if ((gdb_notifier
.poll_fds
+ i
)->revents
)
764 for (file_ptr
= gdb_notifier
.first_file_handler
;
766 file_ptr
= file_ptr
->next_file
)
768 if (file_ptr
->fd
== (gdb_notifier
.poll_fds
+ i
)->fd
)
771 gdb_assert (file_ptr
!= NULL
);
773 mask
= (gdb_notifier
.poll_fds
+ i
)->revents
;
774 handle_file_event (file_ptr
, mask
);
777 internal_error (__FILE__
, __LINE__
,
778 _("use_poll without HAVE_POLL"));
779 #endif /* HAVE_POLL */
783 /* See comment about even source fairness above. */
788 file_ptr
= get_next_file_handler_to_handle_and_advance ();
790 if (FD_ISSET (file_ptr
->fd
, &gdb_notifier
.ready_masks
[0]))
791 mask
|= GDB_READABLE
;
792 if (FD_ISSET (file_ptr
->fd
, &gdb_notifier
.ready_masks
[1]))
793 mask
|= GDB_WRITABLE
;
794 if (FD_ISSET (file_ptr
->fd
, &gdb_notifier
.ready_masks
[2]))
795 mask
|= GDB_EXCEPTION
;
799 handle_file_event (file_ptr
, mask
);
806 /* Create an asynchronous handler, allocating memory for it.
807 Return a pointer to the newly created handler.
808 This pointer will be used to invoke the handler by
809 invoke_async_signal_handler.
810 PROC is the function to call with CLIENT_DATA argument
811 whenever the handler is invoked. */
812 async_signal_handler
*
813 create_async_signal_handler (sig_handler_func
* proc
,
814 gdb_client_data client_data
)
816 async_signal_handler
*async_handler_ptr
;
818 async_handler_ptr
= XNEW (async_signal_handler
);
819 async_handler_ptr
->ready
= 0;
820 async_handler_ptr
->next_handler
= NULL
;
821 async_handler_ptr
->proc
= proc
;
822 async_handler_ptr
->client_data
= client_data
;
823 if (sighandler_list
.first_handler
== NULL
)
824 sighandler_list
.first_handler
= async_handler_ptr
;
826 sighandler_list
.last_handler
->next_handler
= async_handler_ptr
;
827 sighandler_list
.last_handler
= async_handler_ptr
;
828 return async_handler_ptr
;
831 /* Mark the handler (ASYNC_HANDLER_PTR) as ready. This information
832 will be used when the handlers are invoked, after we have waited
833 for some event. The caller of this function is the interrupt
834 handler associated with a signal. */
836 mark_async_signal_handler (async_signal_handler
* async_handler_ptr
)
838 async_handler_ptr
->ready
= 1;
839 serial_event_set (async_signal_handlers_serial_event
);
842 /* See event-loop.h. */
845 clear_async_signal_handler (async_signal_handler
*async_handler_ptr
)
847 async_handler_ptr
->ready
= 0;
850 /* See event-loop.h. */
853 async_signal_handler_is_marked (async_signal_handler
*async_handler_ptr
)
855 return async_handler_ptr
->ready
;
858 /* Call all the handlers that are ready. Returns true if any was
862 invoke_async_signal_handlers (void)
864 async_signal_handler
*async_handler_ptr
;
867 /* We're going to handle all pending signals, so no need to wake up
868 the event loop again the next time around. Note this must be
869 cleared _before_ calling the callbacks, to avoid races. */
870 serial_event_clear (async_signal_handlers_serial_event
);
872 /* Invoke all ready handlers. */
876 for (async_handler_ptr
= sighandler_list
.first_handler
;
877 async_handler_ptr
!= NULL
;
878 async_handler_ptr
= async_handler_ptr
->next_handler
)
880 if (async_handler_ptr
->ready
)
883 if (async_handler_ptr
== NULL
)
886 async_handler_ptr
->ready
= 0;
887 /* Async signal handlers have no connection to whichever was the
888 current UI, and thus always run on the main one. */
889 current_ui
= main_ui
;
890 (*async_handler_ptr
->proc
) (async_handler_ptr
->client_data
);
896 /* Delete an asynchronous handler (ASYNC_HANDLER_PTR).
897 Free the space allocated for it. */
899 delete_async_signal_handler (async_signal_handler
** async_handler_ptr
)
901 async_signal_handler
*prev_ptr
;
903 if (sighandler_list
.first_handler
== (*async_handler_ptr
))
905 sighandler_list
.first_handler
= (*async_handler_ptr
)->next_handler
;
906 if (sighandler_list
.first_handler
== NULL
)
907 sighandler_list
.last_handler
= NULL
;
911 prev_ptr
= sighandler_list
.first_handler
;
912 while (prev_ptr
&& prev_ptr
->next_handler
!= (*async_handler_ptr
))
913 prev_ptr
= prev_ptr
->next_handler
;
914 gdb_assert (prev_ptr
);
915 prev_ptr
->next_handler
= (*async_handler_ptr
)->next_handler
;
916 if (sighandler_list
.last_handler
== (*async_handler_ptr
))
917 sighandler_list
.last_handler
= prev_ptr
;
919 xfree ((*async_handler_ptr
));
920 (*async_handler_ptr
) = NULL
;
923 /* Create an asynchronous event handler, allocating memory for it.
924 Return a pointer to the newly created handler. PROC is the
925 function to call with CLIENT_DATA argument whenever the handler is
927 async_event_handler
*
928 create_async_event_handler (async_event_handler_func
*proc
,
929 gdb_client_data client_data
)
931 async_event_handler
*h
;
933 h
= XNEW (struct async_event_handler
);
935 h
->next_handler
= NULL
;
937 h
->client_data
= client_data
;
938 if (async_event_handler_list
.first_handler
== NULL
)
939 async_event_handler_list
.first_handler
= h
;
941 async_event_handler_list
.last_handler
->next_handler
= h
;
942 async_event_handler_list
.last_handler
= h
;
946 /* Mark the handler (ASYNC_HANDLER_PTR) as ready. This information
947 will be used by gdb_do_one_event. The caller will be whoever
948 created the event source, and wants to signal that the event is
949 ready to be handled. */
951 mark_async_event_handler (async_event_handler
*async_handler_ptr
)
953 async_handler_ptr
->ready
= 1;
956 /* See event-loop.h. */
959 clear_async_event_handler (async_event_handler
*async_handler_ptr
)
961 async_handler_ptr
->ready
= 0;
964 /* Check if asynchronous event handlers are ready, and call the
965 handler function for one that is. */
968 check_async_event_handlers (void)
970 async_event_handler
*async_handler_ptr
;
972 for (async_handler_ptr
= async_event_handler_list
.first_handler
;
973 async_handler_ptr
!= NULL
;
974 async_handler_ptr
= async_handler_ptr
->next_handler
)
976 if (async_handler_ptr
->ready
)
978 async_handler_ptr
->ready
= 0;
979 (*async_handler_ptr
->proc
) (async_handler_ptr
->client_data
);
987 /* Delete an asynchronous handler (ASYNC_HANDLER_PTR).
988 Free the space allocated for it. */
990 delete_async_event_handler (async_event_handler
**async_handler_ptr
)
992 async_event_handler
*prev_ptr
;
994 if (async_event_handler_list
.first_handler
== *async_handler_ptr
)
996 async_event_handler_list
.first_handler
997 = (*async_handler_ptr
)->next_handler
;
998 if (async_event_handler_list
.first_handler
== NULL
)
999 async_event_handler_list
.last_handler
= NULL
;
1003 prev_ptr
= async_event_handler_list
.first_handler
;
1004 while (prev_ptr
&& prev_ptr
->next_handler
!= *async_handler_ptr
)
1005 prev_ptr
= prev_ptr
->next_handler
;
1006 gdb_assert (prev_ptr
);
1007 prev_ptr
->next_handler
= (*async_handler_ptr
)->next_handler
;
1008 if (async_event_handler_list
.last_handler
== (*async_handler_ptr
))
1009 async_event_handler_list
.last_handler
= prev_ptr
;
1011 xfree (*async_handler_ptr
);
1012 *async_handler_ptr
= NULL
;
1015 /* Create a timer that will expire in MS milliseconds from now. When
1016 the timer is ready, PROC will be executed. At creation, the timer
1017 is added to the timers queue. This queue is kept sorted in order
1018 of increasing timers. Return a handle to the timer struct. */
1021 create_timer (int ms
, timer_handler_func
*proc
,
1022 gdb_client_data client_data
)
1024 using namespace std::chrono
;
1025 struct gdb_timer
*timer_ptr
, *timer_index
, *prev_timer
;
1027 steady_clock::time_point time_now
= steady_clock::now ();
1029 timer_ptr
= new gdb_timer ();
1030 timer_ptr
->when
= time_now
+ milliseconds (ms
);
1031 timer_ptr
->proc
= proc
;
1032 timer_ptr
->client_data
= client_data
;
1033 timer_list
.num_timers
++;
1034 timer_ptr
->timer_id
= timer_list
.num_timers
;
1036 /* Now add the timer to the timer queue, making sure it is sorted in
1037 increasing order of expiration. */
1039 for (timer_index
= timer_list
.first_timer
;
1040 timer_index
!= NULL
;
1041 timer_index
= timer_index
->next
)
1043 if (timer_index
->when
> timer_ptr
->when
)
1047 if (timer_index
== timer_list
.first_timer
)
1049 timer_ptr
->next
= timer_list
.first_timer
;
1050 timer_list
.first_timer
= timer_ptr
;
1055 for (prev_timer
= timer_list
.first_timer
;
1056 prev_timer
->next
!= timer_index
;
1057 prev_timer
= prev_timer
->next
)
1060 prev_timer
->next
= timer_ptr
;
1061 timer_ptr
->next
= timer_index
;
1064 gdb_notifier
.timeout_valid
= 0;
1065 return timer_ptr
->timer_id
;
1068 /* There is a chance that the creator of the timer wants to get rid of
1069 it before it expires. */
1071 delete_timer (int id
)
1073 struct gdb_timer
*timer_ptr
, *prev_timer
= NULL
;
1075 /* Find the entry for the given timer. */
1077 for (timer_ptr
= timer_list
.first_timer
; timer_ptr
!= NULL
;
1078 timer_ptr
= timer_ptr
->next
)
1080 if (timer_ptr
->timer_id
== id
)
1084 if (timer_ptr
== NULL
)
1086 /* Get rid of the timer in the timer list. */
1087 if (timer_ptr
== timer_list
.first_timer
)
1088 timer_list
.first_timer
= timer_ptr
->next
;
1091 for (prev_timer
= timer_list
.first_timer
;
1092 prev_timer
->next
!= timer_ptr
;
1093 prev_timer
= prev_timer
->next
)
1095 prev_timer
->next
= timer_ptr
->next
;
1099 gdb_notifier
.timeout_valid
= 0;
1102 /* Convert a std::chrono duration to a struct timeval. */
1104 template<typename Duration
>
1105 static struct timeval
1106 duration_cast_timeval (const Duration
&d
)
1108 using namespace std::chrono
;
1109 seconds sec
= duration_cast
<seconds
> (d
);
1110 microseconds msec
= duration_cast
<microseconds
> (d
- sec
);
1113 tv
.tv_sec
= sec
.count ();
1114 tv
.tv_usec
= msec
.count ();
1118 /* Update the timeout for the select() or poll(). Returns true if the
1119 timer has already expired, false otherwise. */
1122 update_wait_timeout (void)
1124 if (timer_list
.first_timer
!= NULL
)
1126 using namespace std::chrono
;
1127 steady_clock::time_point time_now
= steady_clock::now ();
1128 struct timeval timeout
;
1130 if (timer_list
.first_timer
->when
< time_now
)
1132 /* It expired already. */
1134 timeout
.tv_usec
= 0;
1138 steady_clock::duration d
= timer_list
.first_timer
->when
- time_now
;
1139 timeout
= duration_cast_timeval (d
);
1142 /* Update the timeout for select/ poll. */
1146 gdb_notifier
.poll_timeout
= timeout
.tv_sec
* 1000;
1148 internal_error (__FILE__
, __LINE__
,
1149 _("use_poll without HAVE_POLL"));
1150 #endif /* HAVE_POLL */
1154 gdb_notifier
.select_timeout
.tv_sec
= timeout
.tv_sec
;
1155 gdb_notifier
.select_timeout
.tv_usec
= timeout
.tv_usec
;
1157 gdb_notifier
.timeout_valid
= 1;
1159 if (timer_list
.first_timer
->when
< time_now
)
1163 gdb_notifier
.timeout_valid
= 0;
1168 /* Check whether a timer in the timers queue is ready. If a timer is
1169 ready, call its handler and return. Update the timeout for the
1170 select() or poll() as well. Return 1 if an event was handled,
1171 otherwise returns 0.*/
1176 if (update_wait_timeout ())
1178 struct gdb_timer
*timer_ptr
= timer_list
.first_timer
;
1179 timer_handler_func
*proc
= timer_ptr
->proc
;
1180 gdb_client_data client_data
= timer_ptr
->client_data
;
1182 /* Get rid of the timer from the beginning of the list. */
1183 timer_list
.first_timer
= timer_ptr
->next
;
1185 /* Delete the timer before calling the callback, not after, in
1186 case the callback itself decides to try deleting the timer
1190 /* Call the procedure associated with that timer. */
1191 (proc
) (client_data
);