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>
35 #include "exceptions.h"
36 #include "gdb_select.h"
39 /* Tell create_file_handler what events we are interested in.
40 This is used by the select version of the event loop. */
42 #define GDB_READABLE (1<<1)
43 #define GDB_WRITABLE (1<<2)
44 #define GDB_EXCEPTION (1<<3)
46 /* Data point to pass to the event handler. */
47 typedef union event_data
53 typedef struct gdb_event gdb_event
;
54 typedef void (event_handler_func
) (event_data
);
56 /* Event for the GDB event system. Events are queued by calling
57 async_queue_event and serviced later on by gdb_do_one_event. An
58 event can be, for instance, a file descriptor becoming ready to be
59 read. Servicing an event simply means that the procedure PROC will
60 be called. We have 2 queues, one for file handlers that we listen
61 to in the event loop, and one for the file handlers+events that are
62 ready. The procedure PROC associated with each event is dependant
63 of the event source. In the case of monitored file descriptors, it
64 is always the same (handle_file_event). Its duty is to invoke the
65 handler associated with the file descriptor whose state change
66 generated the event, plus doing other cleanups and such. In the
67 case of async signal handlers, it is
68 invoke_async_signal_handler. */
70 typedef struct gdb_event
72 /* Procedure to call to service this event. */
73 event_handler_func
*proc
;
75 /* Data to pass to the event handler. */
79 /* Information about each file descriptor we register with the event
82 typedef struct file_handler
84 int fd
; /* File descriptor. */
85 int mask
; /* Events we want to monitor: POLLIN, etc. */
86 int ready_mask
; /* Events that have been seen since
88 handler_func
*proc
; /* Procedure to call when fd is ready. */
89 gdb_client_data client_data
; /* Argument to pass to proc. */
90 int error
; /* Was an error detected on this fd? */
91 struct file_handler
*next_file
; /* Next registered file descriptor. */
95 /* PROC is a function to be invoked when the READY flag is set. This
96 happens when there has been a signal and the corresponding signal
97 handler has 'triggered' this async_signal_handler for execution.
98 The actual work to be done in response to a signal will be carried
99 out by PROC at a later time, within process_event. This provides a
100 deferred execution of signal handlers.
102 Async_init_signals takes care of setting up such an
103 async_signal_handler for each interesting signal. */
105 typedef struct async_signal_handler
107 int ready
; /* If ready, call this handler
108 from the main event loop, using
109 invoke_async_handler. */
110 struct async_signal_handler
*next_handler
; /* Ptr to next handler. */
111 sig_handler_func
*proc
; /* Function to call to do the work. */
112 gdb_client_data client_data
; /* Argument to async_handler_func. */
114 async_signal_handler
;
116 /* PROC is a function to be invoked when the READY flag is set. This
117 happens when the event has been marked with
118 MARK_ASYNC_EVENT_HANDLER. The actual work to be done in response
119 to an event will be carried out by PROC at a later time, within
120 process_event. This provides a deferred execution of event
122 typedef struct async_event_handler
124 /* If ready, call this handler from the main event loop, using
125 invoke_event_handler. */
128 /* Point to next handler. */
129 struct async_event_handler
*next_handler
;
131 /* Function to call to do the work. */
132 async_event_handler_func
*proc
;
134 /* Argument to PROC. */
135 gdb_client_data client_data
;
139 DECLARE_QUEUE_P(gdb_event_p
);
140 DEFINE_QUEUE_P(gdb_event_p
);
141 static QUEUE(gdb_event_p
) *event_queue
= NULL
;
143 /* Gdb_notifier is just a list of file descriptors gdb is interested in.
144 These are the input file descriptor, and the target file
145 descriptor. We have two flavors of the notifier, one for platforms
146 that have the POLL function, the other for those that don't, and
147 only support SELECT. Each of the elements in the gdb_notifier list is
148 basically a description of what kind of events gdb is interested
151 /* As of 1999-04-30 only the input file descriptor is registered with the
154 /* Do we use poll or select ? */
159 #endif /* HAVE_POLL */
161 static unsigned char use_poll
= USE_POLL
;
170 /* Ptr to head of file handler list. */
171 file_handler
*first_file_handler
;
174 /* Ptr to array of pollfd structures. */
175 struct pollfd
*poll_fds
;
177 /* Timeout in milliseconds for calls to poll(). */
181 /* Masks to be used in the next call to select.
182 Bits are set in response to calls to create_file_handler. */
183 fd_set check_masks
[3];
185 /* What file descriptors were found ready by select. */
186 fd_set ready_masks
[3];
188 /* Number of file descriptors to monitor (for poll). */
189 /* Number of valid bits (highest fd value + 1) (for select). */
192 /* Time structure for calls to select(). */
193 struct timeval select_timeout
;
195 /* Flag to tell whether the timeout should be used. */
200 /* Structure associated with a timer. PROC will be executed at the
201 first occasion after WHEN. */
206 struct gdb_timer
*next
;
207 timer_handler_func
*proc
; /* Function to call to do the work. */
208 gdb_client_data client_data
; /* Argument to async_handler_func. */
211 /* List of currently active timers. It is sorted in order of
212 increasing timers. */
215 /* Pointer to first in timer list. */
216 struct gdb_timer
*first_timer
;
218 /* Id of the last timer created. */
223 /* All the async_signal_handlers gdb is interested in are kept onto
227 /* Pointer to first in handler list. */
228 async_signal_handler
*first_handler
;
230 /* Pointer to last in handler list. */
231 async_signal_handler
*last_handler
;
235 /* All the async_event_handlers gdb is interested in are kept onto
239 /* Pointer to first in handler list. */
240 async_event_handler
*first_handler
;
242 /* Pointer to last in handler list. */
243 async_event_handler
*last_handler
;
245 async_event_handler_list
;
247 static int invoke_async_signal_handlers (void);
248 static void create_file_handler (int fd
, int mask
, handler_func
*proc
,
249 gdb_client_data client_data
);
250 static void handle_file_event (event_data data
);
251 static void check_async_event_handlers (void);
252 static int gdb_wait_for_event (int);
253 static void poll_timers (void);
256 /* Create a generic event, to be enqueued in the event queue for
257 processing. PROC is the procedure associated to the event. DATA
258 is passed to PROC upon PROC invocation. */
261 create_event (event_handler_func proc
, event_data data
)
265 event
= xmalloc (sizeof (*event
));
272 /* Create a file event, to be enqueued in the event queue for
273 processing. The procedure associated to this event is always
274 handle_file_event, which will in turn invoke the one that was
275 associated to FD when it was registered with the event loop. */
277 create_file_event (int fd
)
282 return create_event (handle_file_event
, data
);
289 gdb_event_xfree (struct gdb_event
*event
)
294 /* Initialize the event queue. */
297 initialize_event_loop (void)
299 event_queue
= QUEUE_alloc (gdb_event_p
, gdb_event_xfree
);
302 /* Process one event.
303 The event can be the next one to be serviced in the event queue,
304 or an asynchronous event handler can be invoked in response to
305 the reception of a signal.
306 If an event was processed (either way), 1 is returned otherwise
308 Scan the queue from head to tail, processing therefore the high
309 priority events first, by invoking the associated event handler
314 /* First let's see if there are any asynchronous event handlers that
315 are ready. These would be the result of invoking any of the
318 if (invoke_async_signal_handlers ())
321 /* Look in the event queue to find an event that is ready
324 if (!QUEUE_is_empty (gdb_event_p
, event_queue
))
326 /* Let's get rid of the event from the event queue. We need to
327 do this now because while processing the event, the proc
328 function could end up calling 'error' and therefore jump out
329 to the caller of this function, gdb_do_one_event. In that
330 case, we would have on the event queue an event wich has been
331 processed, but not deleted. */
332 gdb_event
*event_ptr
= QUEUE_deque (gdb_event_p
, event_queue
);
333 /* Call the handler for the event. */
334 event_handler_func
*proc
= event_ptr
->proc
;
335 event_data data
= event_ptr
->data
;
337 gdb_event_xfree (event_ptr
);
339 /* Now call the procedure associated with the event. */
344 /* This is the case if there are no event on the event queue. */
348 /* Process one high level event. If nothing is ready at this time,
349 wait for something to happen (via gdb_wait_for_event), then process
350 it. Returns >0 if something was done otherwise returns <0 (this
351 can happen if there are no event sources to wait for). */
354 gdb_do_one_event (void)
356 static int event_source_head
= 0;
357 const int number_of_sources
= 3;
360 /* Any events already waiting in the queue? */
361 if (process_event ())
364 /* To level the fairness across event sources, we poll them in a
365 round-robin fashion. */
366 for (current
= 0; current
< number_of_sources
; current
++)
368 switch (event_source_head
)
371 /* Are any timers that are ready? If so, put an event on the
376 /* Are there events already waiting to be collected on the
377 monitored file descriptors? */
378 gdb_wait_for_event (0);
381 /* Are there any asynchronous event handlers ready? */
382 check_async_event_handlers ();
387 if (event_source_head
== number_of_sources
)
388 event_source_head
= 0;
391 /* Handle any new events collected. */
392 if (process_event ())
395 /* Block waiting for a new event. If gdb_wait_for_event returns -1,
396 we should get out because this means that there are no event
397 sources left. This will make the event loop stop, and the
400 if (gdb_wait_for_event (1) < 0)
403 /* Handle any new events occurred while waiting. */
404 if (process_event ())
407 /* If gdb_wait_for_event has returned 1, it means that one event has
408 been handled. We break out of the loop. */
412 /* Start up the event loop. This is the entry point to the event loop
413 from the command loop. */
416 start_event_loop (void)
418 /* Loop until there is nothing to do. This is the entry point to
419 the event loop engine. gdb_do_one_event will process one event
420 for each invocation. It blocks waiting for an event and then
424 volatile struct gdb_exception ex
;
427 TRY_CATCH (ex
, RETURN_MASK_ALL
)
429 result
= gdb_do_one_event ();
433 exception_print (gdb_stderr
, ex
);
435 /* If any exception escaped to here, we better enable
436 stdin. Otherwise, any command that calls async_disable_stdin,
437 and then throws, will leave stdin inoperable. */
438 async_enable_stdin ();
439 /* If we long-jumped out of do_one_event, we probably didn't
440 get around to resetting the prompt, which leaves readline
441 in a messed-up state. Reset it here. */
442 observer_notify_command_error ();
443 /* This call looks bizarre, but it is required. If the user
444 entered a command that caused an error,
445 after_char_processing_hook won't be called from
446 rl_callback_read_char_wrapper. Using a cleanup there
447 won't work, since we want this function to be called
448 after a new prompt is printed. */
449 if (after_char_processing_hook
)
450 (*after_char_processing_hook
) ();
451 /* Maybe better to set a flag to be checked somewhere as to
452 whether display the prompt or not. */
458 /* We are done with the event loop. There are no more event sources
459 to listen to. So we exit GDB. */
464 /* Wrapper function for create_file_handler, so that the caller
465 doesn't have to know implementation details about the use of poll
468 add_file_handler (int fd
, handler_func
* proc
, gdb_client_data client_data
)
477 /* Check to see if poll () is usable. If not, we'll switch to
478 use select. This can happen on systems like
479 m68k-motorola-sys, `poll' cannot be used to wait for `stdin'.
480 On m68k-motorola-sysv, tty's are not stream-based and not
484 if (poll (&fds
, 1, 0) == 1 && (fds
.revents
& POLLNVAL
))
487 internal_error (__FILE__
, __LINE__
,
488 _("use_poll without HAVE_POLL"));
489 #endif /* HAVE_POLL */
494 create_file_handler (fd
, POLLIN
, proc
, client_data
);
496 internal_error (__FILE__
, __LINE__
,
497 _("use_poll without HAVE_POLL"));
501 create_file_handler (fd
, GDB_READABLE
| GDB_EXCEPTION
,
505 /* Add a file handler/descriptor to the list of descriptors we are
508 FD is the file descriptor for the file/stream to be listened to.
510 For the poll case, MASK is a combination (OR) of POLLIN,
511 POLLRDNORM, POLLRDBAND, POLLPRI, POLLOUT, POLLWRNORM, POLLWRBAND:
512 these are the events we are interested in. If any of them occurs,
513 proc should be called.
515 For the select case, MASK is a combination of READABLE, WRITABLE,
516 EXCEPTION. PROC is the procedure that will be called when an event
517 occurs for FD. CLIENT_DATA is the argument to pass to PROC. */
520 create_file_handler (int fd
, int mask
, handler_func
* proc
,
521 gdb_client_data client_data
)
523 file_handler
*file_ptr
;
525 /* Do we already have a file handler for this file? (We may be
526 changing its associated procedure). */
527 for (file_ptr
= gdb_notifier
.first_file_handler
; file_ptr
!= NULL
;
528 file_ptr
= file_ptr
->next_file
)
530 if (file_ptr
->fd
== fd
)
534 /* It is a new file descriptor. Add it to the list. Otherwise, just
535 change the data associated with it. */
536 if (file_ptr
== NULL
)
538 file_ptr
= (file_handler
*) xmalloc (sizeof (file_handler
));
540 file_ptr
->ready_mask
= 0;
541 file_ptr
->next_file
= gdb_notifier
.first_file_handler
;
542 gdb_notifier
.first_file_handler
= file_ptr
;
547 gdb_notifier
.num_fds
++;
548 if (gdb_notifier
.poll_fds
)
549 gdb_notifier
.poll_fds
=
550 (struct pollfd
*) xrealloc (gdb_notifier
.poll_fds
,
551 (gdb_notifier
.num_fds
552 * sizeof (struct pollfd
)));
554 gdb_notifier
.poll_fds
=
555 (struct pollfd
*) xmalloc (sizeof (struct pollfd
));
556 (gdb_notifier
.poll_fds
+ gdb_notifier
.num_fds
- 1)->fd
= fd
;
557 (gdb_notifier
.poll_fds
+ gdb_notifier
.num_fds
- 1)->events
= mask
;
558 (gdb_notifier
.poll_fds
+ gdb_notifier
.num_fds
- 1)->revents
= 0;
560 internal_error (__FILE__
, __LINE__
,
561 _("use_poll without HAVE_POLL"));
562 #endif /* HAVE_POLL */
566 if (mask
& GDB_READABLE
)
567 FD_SET (fd
, &gdb_notifier
.check_masks
[0]);
569 FD_CLR (fd
, &gdb_notifier
.check_masks
[0]);
571 if (mask
& GDB_WRITABLE
)
572 FD_SET (fd
, &gdb_notifier
.check_masks
[1]);
574 FD_CLR (fd
, &gdb_notifier
.check_masks
[1]);
576 if (mask
& GDB_EXCEPTION
)
577 FD_SET (fd
, &gdb_notifier
.check_masks
[2]);
579 FD_CLR (fd
, &gdb_notifier
.check_masks
[2]);
581 if (gdb_notifier
.num_fds
<= fd
)
582 gdb_notifier
.num_fds
= fd
+ 1;
586 file_ptr
->proc
= proc
;
587 file_ptr
->client_data
= client_data
;
588 file_ptr
->mask
= mask
;
591 /* Remove the file descriptor FD from the list of monitored fd's:
592 i.e. we don't care anymore about events on the FD. */
594 delete_file_handler (int fd
)
596 file_handler
*file_ptr
, *prev_ptr
= NULL
;
600 struct pollfd
*new_poll_fds
;
603 /* Find the entry for the given file. */
605 for (file_ptr
= gdb_notifier
.first_file_handler
; file_ptr
!= NULL
;
606 file_ptr
= file_ptr
->next_file
)
608 if (file_ptr
->fd
== fd
)
612 if (file_ptr
== NULL
)
618 /* Create a new poll_fds array by copying every fd's information
619 but the one we want to get rid of. */
621 new_poll_fds
= (struct pollfd
*)
622 xmalloc ((gdb_notifier
.num_fds
- 1) * sizeof (struct pollfd
));
624 for (i
= 0, j
= 0; i
< gdb_notifier
.num_fds
; i
++)
626 if ((gdb_notifier
.poll_fds
+ i
)->fd
!= fd
)
628 (new_poll_fds
+ j
)->fd
= (gdb_notifier
.poll_fds
+ i
)->fd
;
629 (new_poll_fds
+ j
)->events
= (gdb_notifier
.poll_fds
+ i
)->events
;
630 (new_poll_fds
+ j
)->revents
631 = (gdb_notifier
.poll_fds
+ i
)->revents
;
635 xfree (gdb_notifier
.poll_fds
);
636 gdb_notifier
.poll_fds
= new_poll_fds
;
637 gdb_notifier
.num_fds
--;
639 internal_error (__FILE__
, __LINE__
,
640 _("use_poll without HAVE_POLL"));
641 #endif /* HAVE_POLL */
645 if (file_ptr
->mask
& GDB_READABLE
)
646 FD_CLR (fd
, &gdb_notifier
.check_masks
[0]);
647 if (file_ptr
->mask
& GDB_WRITABLE
)
648 FD_CLR (fd
, &gdb_notifier
.check_masks
[1]);
649 if (file_ptr
->mask
& GDB_EXCEPTION
)
650 FD_CLR (fd
, &gdb_notifier
.check_masks
[2]);
652 /* Find current max fd. */
654 if ((fd
+ 1) == gdb_notifier
.num_fds
)
656 gdb_notifier
.num_fds
--;
657 for (i
= gdb_notifier
.num_fds
; i
; i
--)
659 if (FD_ISSET (i
- 1, &gdb_notifier
.check_masks
[0])
660 || FD_ISSET (i
- 1, &gdb_notifier
.check_masks
[1])
661 || FD_ISSET (i
- 1, &gdb_notifier
.check_masks
[2]))
664 gdb_notifier
.num_fds
= i
;
668 /* Deactivate the file descriptor, by clearing its mask,
669 so that it will not fire again. */
673 /* Get rid of the file handler in the file handler list. */
674 if (file_ptr
== gdb_notifier
.first_file_handler
)
675 gdb_notifier
.first_file_handler
= file_ptr
->next_file
;
678 for (prev_ptr
= gdb_notifier
.first_file_handler
;
679 prev_ptr
->next_file
!= file_ptr
;
680 prev_ptr
= prev_ptr
->next_file
)
682 prev_ptr
->next_file
= file_ptr
->next_file
;
687 /* Handle the given event by calling the procedure associated to the
688 corresponding file handler. Called by process_event indirectly,
689 through event_ptr->proc. EVENT_FILE_DESC is file descriptor of the
690 event in the front of the event queue. */
692 handle_file_event (event_data data
)
694 file_handler
*file_ptr
;
699 int event_file_desc
= data
.integer
;
701 /* Search the file handler list to find one that matches the fd in
703 for (file_ptr
= gdb_notifier
.first_file_handler
; file_ptr
!= NULL
;
704 file_ptr
= file_ptr
->next_file
)
706 if (file_ptr
->fd
== event_file_desc
)
708 /* With poll, the ready_mask could have any of three events
709 set to 1: POLLHUP, POLLERR, POLLNVAL. These events
710 cannot be used in the requested event mask (events), but
711 they can be returned in the return mask (revents). We
712 need to check for those event too, and add them to the
713 mask which will be passed to the handler. */
715 /* See if the desired events (mask) match the received
716 events (ready_mask). */
721 /* POLLHUP means EOF, but can be combined with POLLIN to
722 signal more data to read. */
723 error_mask
= POLLHUP
| POLLERR
| POLLNVAL
;
724 mask
= file_ptr
->ready_mask
& (file_ptr
->mask
| error_mask
);
726 if ((mask
& (POLLERR
| POLLNVAL
)) != 0)
728 /* Work in progress. We may need to tell somebody
729 what kind of error we had. */
731 printf_unfiltered (_("Error detected on fd %d\n"),
734 printf_unfiltered (_("Invalid or non-`poll'able fd %d\n"),
741 internal_error (__FILE__
, __LINE__
,
742 _("use_poll without HAVE_POLL"));
743 #endif /* HAVE_POLL */
747 if (file_ptr
->ready_mask
& GDB_EXCEPTION
)
749 printf_unfiltered (_("Exception condition detected "
750 "on fd %d\n"), file_ptr
->fd
);
755 mask
= file_ptr
->ready_mask
& file_ptr
->mask
;
758 /* Clear the received events for next time around. */
759 file_ptr
->ready_mask
= 0;
761 /* If there was a match, then call the handler. */
763 (*file_ptr
->proc
) (file_ptr
->error
, file_ptr
->client_data
);
769 /* Called by gdb_do_one_event to wait for new events on the monitored
770 file descriptors. Queue file events as they are detected by the
771 poll. If BLOCK and if there are no events, this function will
772 block in the call to poll. Return -1 if there are no file
773 descriptors to monitor, otherwise return 0. */
775 gdb_wait_for_event (int block
)
777 file_handler
*file_ptr
;
778 gdb_event
*file_event_ptr
;
782 /* Make sure all output is done before getting another event. */
783 gdb_flush (gdb_stdout
);
784 gdb_flush (gdb_stderr
);
786 if (gdb_notifier
.num_fds
== 0)
795 timeout
= gdb_notifier
.timeout_valid
? gdb_notifier
.poll_timeout
: -1;
799 num_found
= poll (gdb_notifier
.poll_fds
,
800 (unsigned long) gdb_notifier
.num_fds
, timeout
);
802 /* Don't print anything if we get out of poll because of a
804 if (num_found
== -1 && errno
!= EINTR
)
805 perror_with_name (("poll"));
807 internal_error (__FILE__
, __LINE__
,
808 _("use_poll without HAVE_POLL"));
809 #endif /* HAVE_POLL */
813 struct timeval select_timeout
;
814 struct timeval
*timeout_p
;
817 timeout_p
= gdb_notifier
.timeout_valid
818 ? &gdb_notifier
.select_timeout
: NULL
;
821 memset (&select_timeout
, 0, sizeof (select_timeout
));
822 timeout_p
= &select_timeout
;
825 gdb_notifier
.ready_masks
[0] = gdb_notifier
.check_masks
[0];
826 gdb_notifier
.ready_masks
[1] = gdb_notifier
.check_masks
[1];
827 gdb_notifier
.ready_masks
[2] = gdb_notifier
.check_masks
[2];
828 num_found
= gdb_select (gdb_notifier
.num_fds
,
829 &gdb_notifier
.ready_masks
[0],
830 &gdb_notifier
.ready_masks
[1],
831 &gdb_notifier
.ready_masks
[2],
834 /* Clear the masks after an error from select. */
837 FD_ZERO (&gdb_notifier
.ready_masks
[0]);
838 FD_ZERO (&gdb_notifier
.ready_masks
[1]);
839 FD_ZERO (&gdb_notifier
.ready_masks
[2]);
841 /* Dont print anything if we got a signal, let gdb handle
844 perror_with_name (("select"));
848 /* Enqueue all detected file events. */
853 for (i
= 0; (i
< gdb_notifier
.num_fds
) && (num_found
> 0); i
++)
855 if ((gdb_notifier
.poll_fds
+ i
)->revents
)
860 for (file_ptr
= gdb_notifier
.first_file_handler
;
862 file_ptr
= file_ptr
->next_file
)
864 if (file_ptr
->fd
== (gdb_notifier
.poll_fds
+ i
)->fd
)
870 /* Enqueue an event only if this is still a new event for
872 if (file_ptr
->ready_mask
== 0)
874 file_event_ptr
= create_file_event (file_ptr
->fd
);
875 QUEUE_enque (gdb_event_p
, event_queue
, file_event_ptr
);
877 file_ptr
->ready_mask
= (gdb_notifier
.poll_fds
+ i
)->revents
;
881 internal_error (__FILE__
, __LINE__
,
882 _("use_poll without HAVE_POLL"));
883 #endif /* HAVE_POLL */
887 for (file_ptr
= gdb_notifier
.first_file_handler
;
888 (file_ptr
!= NULL
) && (num_found
> 0);
889 file_ptr
= file_ptr
->next_file
)
893 if (FD_ISSET (file_ptr
->fd
, &gdb_notifier
.ready_masks
[0]))
894 mask
|= GDB_READABLE
;
895 if (FD_ISSET (file_ptr
->fd
, &gdb_notifier
.ready_masks
[1]))
896 mask
|= GDB_WRITABLE
;
897 if (FD_ISSET (file_ptr
->fd
, &gdb_notifier
.ready_masks
[2]))
898 mask
|= GDB_EXCEPTION
;
905 /* Enqueue an event only if this is still a new event for
908 if (file_ptr
->ready_mask
== 0)
910 file_event_ptr
= create_file_event (file_ptr
->fd
);
911 QUEUE_enque (gdb_event_p
, event_queue
, file_event_ptr
);
913 file_ptr
->ready_mask
= mask
;
920 /* Create an asynchronous handler, allocating memory for it.
921 Return a pointer to the newly created handler.
922 This pointer will be used to invoke the handler by
923 invoke_async_signal_handler.
924 PROC is the function to call with CLIENT_DATA argument
925 whenever the handler is invoked. */
926 async_signal_handler
*
927 create_async_signal_handler (sig_handler_func
* proc
,
928 gdb_client_data client_data
)
930 async_signal_handler
*async_handler_ptr
;
933 (async_signal_handler
*) xmalloc (sizeof (async_signal_handler
));
934 async_handler_ptr
->ready
= 0;
935 async_handler_ptr
->next_handler
= NULL
;
936 async_handler_ptr
->proc
= proc
;
937 async_handler_ptr
->client_data
= client_data
;
938 if (sighandler_list
.first_handler
== NULL
)
939 sighandler_list
.first_handler
= async_handler_ptr
;
941 sighandler_list
.last_handler
->next_handler
= async_handler_ptr
;
942 sighandler_list
.last_handler
= async_handler_ptr
;
943 return async_handler_ptr
;
946 /* Call the handler from HANDLER immediately. This function runs
947 signal handlers when returning to the event loop would be too
950 call_async_signal_handler (struct async_signal_handler
*handler
)
952 (*handler
->proc
) (handler
->client_data
);
955 /* Mark the handler (ASYNC_HANDLER_PTR) as ready. This information
956 will be used when the handlers are invoked, after we have waited
957 for some event. The caller of this function is the interrupt
958 handler associated with a signal. */
960 mark_async_signal_handler (async_signal_handler
* async_handler_ptr
)
962 async_handler_ptr
->ready
= 1;
965 /* Call all the handlers that are ready. Returns true if any was
968 invoke_async_signal_handlers (void)
970 async_signal_handler
*async_handler_ptr
;
973 /* Invoke ready handlers. */
977 for (async_handler_ptr
= sighandler_list
.first_handler
;
978 async_handler_ptr
!= NULL
;
979 async_handler_ptr
= async_handler_ptr
->next_handler
)
981 if (async_handler_ptr
->ready
)
984 if (async_handler_ptr
== NULL
)
987 async_handler_ptr
->ready
= 0;
988 (*async_handler_ptr
->proc
) (async_handler_ptr
->client_data
);
994 /* Delete an asynchronous handler (ASYNC_HANDLER_PTR).
995 Free the space allocated for it. */
997 delete_async_signal_handler (async_signal_handler
** async_handler_ptr
)
999 async_signal_handler
*prev_ptr
;
1001 if (sighandler_list
.first_handler
== (*async_handler_ptr
))
1003 sighandler_list
.first_handler
= (*async_handler_ptr
)->next_handler
;
1004 if (sighandler_list
.first_handler
== NULL
)
1005 sighandler_list
.last_handler
= NULL
;
1009 prev_ptr
= sighandler_list
.first_handler
;
1010 while (prev_ptr
&& prev_ptr
->next_handler
!= (*async_handler_ptr
))
1011 prev_ptr
= prev_ptr
->next_handler
;
1012 gdb_assert (prev_ptr
);
1013 prev_ptr
->next_handler
= (*async_handler_ptr
)->next_handler
;
1014 if (sighandler_list
.last_handler
== (*async_handler_ptr
))
1015 sighandler_list
.last_handler
= prev_ptr
;
1017 xfree ((*async_handler_ptr
));
1018 (*async_handler_ptr
) = NULL
;
1021 /* Create an asynchronous event handler, allocating memory for it.
1022 Return a pointer to the newly created handler. PROC is the
1023 function to call with CLIENT_DATA argument whenever the handler is
1025 async_event_handler
*
1026 create_async_event_handler (async_event_handler_func
*proc
,
1027 gdb_client_data client_data
)
1029 async_event_handler
*h
;
1031 h
= xmalloc (sizeof (*h
));
1033 h
->next_handler
= NULL
;
1035 h
->client_data
= client_data
;
1036 if (async_event_handler_list
.first_handler
== NULL
)
1037 async_event_handler_list
.first_handler
= h
;
1039 async_event_handler_list
.last_handler
->next_handler
= h
;
1040 async_event_handler_list
.last_handler
= h
;
1044 /* Mark the handler (ASYNC_HANDLER_PTR) as ready. This information
1045 will be used by gdb_do_one_event. The caller will be whoever
1046 created the event source, and wants to signal that the event is
1047 ready to be handled. */
1049 mark_async_event_handler (async_event_handler
*async_handler_ptr
)
1051 async_handler_ptr
->ready
= 1;
1054 struct async_event_handler_data
1056 async_event_handler_func
* proc
;
1057 gdb_client_data client_data
;
1061 invoke_async_event_handler (event_data data
)
1063 struct async_event_handler_data
*hdata
= data
.ptr
;
1064 async_event_handler_func
* proc
= hdata
->proc
;
1065 gdb_client_data client_data
= hdata
->client_data
;
1068 (*proc
) (client_data
);
1071 /* Check if any asynchronous event handlers are ready, and queue
1072 events in the ready queue for any that are. */
1074 check_async_event_handlers (void)
1076 async_event_handler
*async_handler_ptr
;
1077 struct async_event_handler_data
*hdata
;
1078 struct gdb_event
*event_ptr
;
1081 for (async_handler_ptr
= async_event_handler_list
.first_handler
;
1082 async_handler_ptr
!= NULL
;
1083 async_handler_ptr
= async_handler_ptr
->next_handler
)
1085 if (async_handler_ptr
->ready
)
1087 async_handler_ptr
->ready
= 0;
1089 hdata
= xmalloc (sizeof (*hdata
));
1091 hdata
->proc
= async_handler_ptr
->proc
;
1092 hdata
->client_data
= async_handler_ptr
->client_data
;
1096 event_ptr
= create_event (invoke_async_event_handler
, data
);
1097 QUEUE_enque (gdb_event_p
, event_queue
, event_ptr
);
1102 /* Delete an asynchronous handler (ASYNC_HANDLER_PTR).
1103 Free the space allocated for it. */
1105 delete_async_event_handler (async_event_handler
**async_handler_ptr
)
1107 async_event_handler
*prev_ptr
;
1109 if (async_event_handler_list
.first_handler
== *async_handler_ptr
)
1111 async_event_handler_list
.first_handler
1112 = (*async_handler_ptr
)->next_handler
;
1113 if (async_event_handler_list
.first_handler
== NULL
)
1114 async_event_handler_list
.last_handler
= NULL
;
1118 prev_ptr
= async_event_handler_list
.first_handler
;
1119 while (prev_ptr
&& prev_ptr
->next_handler
!= *async_handler_ptr
)
1120 prev_ptr
= prev_ptr
->next_handler
;
1121 gdb_assert (prev_ptr
);
1122 prev_ptr
->next_handler
= (*async_handler_ptr
)->next_handler
;
1123 if (async_event_handler_list
.last_handler
== (*async_handler_ptr
))
1124 async_event_handler_list
.last_handler
= prev_ptr
;
1126 xfree (*async_handler_ptr
);
1127 *async_handler_ptr
= NULL
;
1130 /* Create a timer that will expire in MILLISECONDS from now. When the
1131 timer is ready, PROC will be executed. At creation, the timer is
1132 aded to the timers queue. This queue is kept sorted in order of
1133 increasing timers. Return a handle to the timer struct. */
1135 create_timer (int milliseconds
, timer_handler_func
* proc
,
1136 gdb_client_data client_data
)
1138 struct gdb_timer
*timer_ptr
, *timer_index
, *prev_timer
;
1139 struct timeval time_now
, delta
;
1141 /* Compute seconds. */
1142 delta
.tv_sec
= milliseconds
/ 1000;
1143 /* Compute microseconds. */
1144 delta
.tv_usec
= (milliseconds
% 1000) * 1000;
1146 gettimeofday (&time_now
, NULL
);
1148 timer_ptr
= (struct gdb_timer
*) xmalloc (sizeof (*timer_ptr
));
1149 timer_ptr
->when
.tv_sec
= time_now
.tv_sec
+ delta
.tv_sec
;
1150 timer_ptr
->when
.tv_usec
= time_now
.tv_usec
+ delta
.tv_usec
;
1152 if (timer_ptr
->when
.tv_usec
>= 1000000)
1154 timer_ptr
->when
.tv_sec
+= 1;
1155 timer_ptr
->when
.tv_usec
-= 1000000;
1157 timer_ptr
->proc
= proc
;
1158 timer_ptr
->client_data
= client_data
;
1159 timer_list
.num_timers
++;
1160 timer_ptr
->timer_id
= timer_list
.num_timers
;
1162 /* Now add the timer to the timer queue, making sure it is sorted in
1163 increasing order of expiration. */
1165 for (timer_index
= timer_list
.first_timer
;
1166 timer_index
!= NULL
;
1167 timer_index
= timer_index
->next
)
1169 /* If the seconds field is greater or if it is the same, but the
1170 microsecond field is greater. */
1171 if ((timer_index
->when
.tv_sec
> timer_ptr
->when
.tv_sec
)
1172 || ((timer_index
->when
.tv_sec
== timer_ptr
->when
.tv_sec
)
1173 && (timer_index
->when
.tv_usec
> timer_ptr
->when
.tv_usec
)))
1177 if (timer_index
== timer_list
.first_timer
)
1179 timer_ptr
->next
= timer_list
.first_timer
;
1180 timer_list
.first_timer
= timer_ptr
;
1185 for (prev_timer
= timer_list
.first_timer
;
1186 prev_timer
->next
!= timer_index
;
1187 prev_timer
= prev_timer
->next
)
1190 prev_timer
->next
= timer_ptr
;
1191 timer_ptr
->next
= timer_index
;
1194 gdb_notifier
.timeout_valid
= 0;
1195 return timer_ptr
->timer_id
;
1198 /* There is a chance that the creator of the timer wants to get rid of
1199 it before it expires. */
1201 delete_timer (int id
)
1203 struct gdb_timer
*timer_ptr
, *prev_timer
= NULL
;
1205 /* Find the entry for the given timer. */
1207 for (timer_ptr
= timer_list
.first_timer
; timer_ptr
!= NULL
;
1208 timer_ptr
= timer_ptr
->next
)
1210 if (timer_ptr
->timer_id
== id
)
1214 if (timer_ptr
== NULL
)
1216 /* Get rid of the timer in the timer list. */
1217 if (timer_ptr
== timer_list
.first_timer
)
1218 timer_list
.first_timer
= timer_ptr
->next
;
1221 for (prev_timer
= timer_list
.first_timer
;
1222 prev_timer
->next
!= timer_ptr
;
1223 prev_timer
= prev_timer
->next
)
1225 prev_timer
->next
= timer_ptr
->next
;
1229 gdb_notifier
.timeout_valid
= 0;
1232 /* When a timer event is put on the event queue, it will be handled by
1233 this function. Just call the associated procedure and delete the
1234 timer event from the event queue. Repeat this for each timer that
1237 handle_timer_event (event_data dummy
)
1239 struct timeval time_now
;
1240 struct gdb_timer
*timer_ptr
, *saved_timer
;
1242 gettimeofday (&time_now
, NULL
);
1243 timer_ptr
= timer_list
.first_timer
;
1245 while (timer_ptr
!= NULL
)
1247 if ((timer_ptr
->when
.tv_sec
> time_now
.tv_sec
)
1248 || ((timer_ptr
->when
.tv_sec
== time_now
.tv_sec
)
1249 && (timer_ptr
->when
.tv_usec
> time_now
.tv_usec
)))
1252 /* Get rid of the timer from the beginning of the list. */
1253 timer_list
.first_timer
= timer_ptr
->next
;
1254 saved_timer
= timer_ptr
;
1255 timer_ptr
= timer_ptr
->next
;
1256 /* Call the procedure associated with that timer. */
1257 (*saved_timer
->proc
) (saved_timer
->client_data
);
1258 xfree (saved_timer
);
1261 gdb_notifier
.timeout_valid
= 0;
1264 /* Check whether any timers in the timers queue are ready. If at least
1265 one timer is ready, stick an event onto the event queue. Even in
1266 case more than one timer is ready, one event is enough, because the
1267 handle_timer_event() will go through the timers list and call the
1268 procedures associated with all that have expired.l Update the
1269 timeout for the select() or poll() as well. */
1273 struct timeval time_now
, delta
;
1274 gdb_event
*event_ptr
;
1276 if (timer_list
.first_timer
!= NULL
)
1278 gettimeofday (&time_now
, NULL
);
1279 delta
.tv_sec
= timer_list
.first_timer
->when
.tv_sec
- time_now
.tv_sec
;
1280 delta
.tv_usec
= timer_list
.first_timer
->when
.tv_usec
- time_now
.tv_usec
;
1282 if (delta
.tv_usec
< 0)
1285 delta
.tv_usec
+= 1000000;
1288 /* Oops it expired already. Tell select / poll to return
1289 immediately. (Cannot simply test if delta.tv_sec is negative
1290 because time_t might be unsigned.) */
1291 if (timer_list
.first_timer
->when
.tv_sec
< time_now
.tv_sec
1292 || (timer_list
.first_timer
->when
.tv_sec
== time_now
.tv_sec
1293 && timer_list
.first_timer
->when
.tv_usec
< time_now
.tv_usec
))
1299 if (delta
.tv_sec
== 0 && delta
.tv_usec
== 0)
1301 event_ptr
= (gdb_event
*) xmalloc (sizeof (gdb_event
));
1302 event_ptr
->proc
= handle_timer_event
;
1303 event_ptr
->data
.integer
= timer_list
.first_timer
->timer_id
;
1304 QUEUE_enque (gdb_event_p
, event_queue
, event_ptr
);
1307 /* Now we need to update the timeout for select/ poll, because
1308 we don't want to sit there while this timer is expiring. */
1312 gdb_notifier
.poll_timeout
= delta
.tv_sec
* 1000;
1314 internal_error (__FILE__
, __LINE__
,
1315 _("use_poll without HAVE_POLL"));
1316 #endif /* HAVE_POLL */
1320 gdb_notifier
.select_timeout
.tv_sec
= delta
.tv_sec
;
1321 gdb_notifier
.select_timeout
.tv_usec
= delta
.tv_usec
;
1323 gdb_notifier
.timeout_valid
= 1;
1326 gdb_notifier
.timeout_valid
= 0;