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 "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 /* Data point to pass to the event handler. */
46 typedef union event_data
52 typedef struct gdb_event gdb_event
;
53 typedef void (event_handler_func
) (event_data
);
55 /* Event for the GDB event system. Events are queued by calling
56 async_queue_event and serviced later on by gdb_do_one_event. An
57 event can be, for instance, a file descriptor becoming ready to be
58 read. Servicing an event simply means that the procedure PROC will
59 be called. We have 2 queues, one for file handlers that we listen
60 to in the event loop, and one for the file handlers+events that are
61 ready. The procedure PROC associated with each event is dependant
62 of the event source. In the case of monitored file descriptors, it
63 is always the same (handle_file_event). Its duty is to invoke the
64 handler associated with the file descriptor whose state change
65 generated the event, plus doing other cleanups and such. In the
66 case of async signal handlers, it is
67 invoke_async_signal_handler. */
69 typedef struct gdb_event
71 /* Procedure to call to service this event. */
72 event_handler_func
*proc
;
74 /* Data to pass to the event handler. */
78 /* Information about each file descriptor we register with the event
81 typedef struct file_handler
83 int fd
; /* File descriptor. */
84 int mask
; /* Events we want to monitor: POLLIN, etc. */
85 int ready_mask
; /* Events that have been seen since
87 handler_func
*proc
; /* Procedure to call when fd is ready. */
88 gdb_client_data client_data
; /* Argument to pass to proc. */
89 int error
; /* Was an error detected on this fd? */
90 struct file_handler
*next_file
; /* Next registered file descriptor. */
94 /* PROC is a function to be invoked when the READY flag is set. This
95 happens when there has been a signal and the corresponding signal
96 handler has 'triggered' this async_signal_handler for execution.
97 The actual work to be done in response to a signal will be carried
98 out by PROC at a later time, within process_event. This provides a
99 deferred execution of signal handlers.
101 Async_init_signals takes care of setting up such an
102 async_signal_handler for each interesting signal. */
104 typedef struct async_signal_handler
106 int ready
; /* If ready, call this handler
107 from the main event loop, using
108 invoke_async_handler. */
109 struct async_signal_handler
*next_handler
; /* Ptr to next handler. */
110 sig_handler_func
*proc
; /* Function to call to do the work. */
111 gdb_client_data client_data
; /* Argument to async_handler_func. */
113 async_signal_handler
;
115 /* PROC is a function to be invoked when the READY flag is set. This
116 happens when the event has been marked with
117 MARK_ASYNC_EVENT_HANDLER. The actual work to be done in response
118 to an event will be carried out by PROC at a later time, within
119 process_event. This provides a deferred execution of event
121 typedef struct async_event_handler
123 /* If ready, call this handler from the main event loop, using
124 invoke_event_handler. */
127 /* Point to next handler. */
128 struct async_event_handler
*next_handler
;
130 /* Function to call to do the work. */
131 async_event_handler_func
*proc
;
133 /* Argument to PROC. */
134 gdb_client_data client_data
;
138 DECLARE_QUEUE_P(gdb_event_p
);
139 DEFINE_QUEUE_P(gdb_event_p
);
140 static QUEUE(gdb_event_p
) *event_queue
= NULL
;
142 /* Gdb_notifier is just a list of file descriptors gdb is interested in.
143 These are the input file descriptor, and the target file
144 descriptor. We have two flavors of the notifier, one for platforms
145 that have the POLL function, the other for those that don't, and
146 only support SELECT. Each of the elements in the gdb_notifier list is
147 basically a description of what kind of events gdb is interested
150 /* As of 1999-04-30 only the input file descriptor is registered with the
153 /* Do we use poll or select ? */
158 #endif /* HAVE_POLL */
160 static unsigned char use_poll
= USE_POLL
;
169 /* Ptr to head of file handler list. */
170 file_handler
*first_file_handler
;
173 /* Ptr to array of pollfd structures. */
174 struct pollfd
*poll_fds
;
176 /* Timeout in milliseconds for calls to poll(). */
180 /* Masks to be used in the next call to select.
181 Bits are set in response to calls to create_file_handler. */
182 fd_set check_masks
[3];
184 /* What file descriptors were found ready by select. */
185 fd_set ready_masks
[3];
187 /* Number of file descriptors to monitor (for poll). */
188 /* Number of valid bits (highest fd value + 1) (for select). */
191 /* Time structure for calls to select(). */
192 struct timeval select_timeout
;
194 /* Flag to tell whether the timeout should be used. */
199 /* Structure associated with a timer. PROC will be executed at the
200 first occasion after WHEN. */
205 struct gdb_timer
*next
;
206 timer_handler_func
*proc
; /* Function to call to do the work. */
207 gdb_client_data client_data
; /* Argument to async_handler_func. */
210 /* List of currently active timers. It is sorted in order of
211 increasing timers. */
214 /* Pointer to first in timer list. */
215 struct gdb_timer
*first_timer
;
217 /* Id of the last timer created. */
222 /* All the async_signal_handlers gdb is interested in are kept onto
226 /* Pointer to first in handler list. */
227 async_signal_handler
*first_handler
;
229 /* Pointer to last in handler list. */
230 async_signal_handler
*last_handler
;
234 /* All the async_event_handlers gdb is interested in are kept onto
238 /* Pointer to first in handler list. */
239 async_event_handler
*first_handler
;
241 /* Pointer to last in handler list. */
242 async_event_handler
*last_handler
;
244 async_event_handler_list
;
246 static int invoke_async_signal_handlers (void);
247 static void create_file_handler (int fd
, int mask
, handler_func
*proc
,
248 gdb_client_data client_data
);
249 static void handle_file_event (event_data data
);
250 static void check_async_event_handlers (void);
251 static int gdb_wait_for_event (int);
252 static void poll_timers (void);
255 /* Create a generic event, to be enqueued in the event queue for
256 processing. PROC is the procedure associated to the event. DATA
257 is passed to PROC upon PROC invocation. */
260 create_event (event_handler_func proc
, event_data data
)
264 event
= xmalloc (sizeof (*event
));
271 /* Create a file event, to be enqueued in the event queue for
272 processing. The procedure associated to this event is always
273 handle_file_event, which will in turn invoke the one that was
274 associated to FD when it was registered with the event loop. */
276 create_file_event (int fd
)
281 return create_event (handle_file_event
, data
);
288 gdb_event_xfree (struct gdb_event
*event
)
293 /* Initialize the event queue. */
296 initialize_event_loop (void)
298 event_queue
= QUEUE_alloc (gdb_event_p
, gdb_event_xfree
);
301 /* Process one event.
302 The event can be the next one to be serviced in the event queue,
303 or an asynchronous event handler can be invoked in response to
304 the reception of a signal.
305 If an event was processed (either way), 1 is returned otherwise
307 Scan the queue from head to tail, processing therefore the high
308 priority events first, by invoking the associated event handler
313 /* First let's see if there are any asynchronous event handlers that
314 are ready. These would be the result of invoking any of the
317 if (invoke_async_signal_handlers ())
320 /* Look in the event queue to find an event that is ready
323 if (!QUEUE_is_empty (gdb_event_p
, event_queue
))
325 /* Let's get rid of the event from the event queue. We need to
326 do this now because while processing the event, the proc
327 function could end up calling 'error' and therefore jump out
328 to the caller of this function, gdb_do_one_event. In that
329 case, we would have on the event queue an event wich has been
330 processed, but not deleted. */
331 gdb_event
*event_ptr
= QUEUE_deque (gdb_event_p
, event_queue
);
332 /* Call the handler for the event. */
333 event_handler_func
*proc
= event_ptr
->proc
;
334 event_data data
= event_ptr
->data
;
336 gdb_event_xfree (event_ptr
);
338 /* Now call the procedure associated with the event. */
343 /* This is the case if there are no event on the event queue. */
347 /* Process one high level event. If nothing is ready at this time,
348 wait for something to happen (via gdb_wait_for_event), then process
349 it. Returns >0 if something was done otherwise returns <0 (this
350 can happen if there are no event sources to wait for). */
353 gdb_do_one_event (void)
355 static int event_source_head
= 0;
356 const int number_of_sources
= 3;
359 /* Any events already waiting in the queue? */
360 if (process_event ())
363 /* To level the fairness across event sources, we poll them in a
364 round-robin fashion. */
365 for (current
= 0; current
< number_of_sources
; current
++)
367 switch (event_source_head
)
370 /* Are any timers that are ready? If so, put an event on the
375 /* Are there events already waiting to be collected on the
376 monitored file descriptors? */
377 gdb_wait_for_event (0);
380 /* Are there any asynchronous event handlers ready? */
381 check_async_event_handlers ();
386 if (event_source_head
== number_of_sources
)
387 event_source_head
= 0;
390 /* Handle any new events collected. */
391 if (process_event ())
394 /* Block waiting for a new event. If gdb_wait_for_event returns -1,
395 we should get out because this means that there are no event
396 sources left. This will make the event loop stop, and the
399 if (gdb_wait_for_event (1) < 0)
402 /* Handle any new events occurred while waiting. */
403 if (process_event ())
406 /* If gdb_wait_for_event has returned 1, it means that one event has
407 been handled. We break out of the loop. */
411 /* Start up the event loop. This is the entry point to the event loop
412 from the command loop. */
415 start_event_loop (void)
417 /* Loop until there is nothing to do. This is the entry point to
418 the event loop engine. gdb_do_one_event will process one event
419 for each invocation. It blocks waiting for an event and then
423 volatile struct gdb_exception ex
;
426 TRY_CATCH (ex
, RETURN_MASK_ALL
)
428 result
= gdb_do_one_event ();
432 exception_print (gdb_stderr
, ex
);
434 /* If any exception escaped to here, we better enable
435 stdin. Otherwise, any command that calls async_disable_stdin,
436 and then throws, will leave stdin inoperable. */
437 async_enable_stdin ();
438 /* If we long-jumped out of do_one_event, we probably didn't
439 get around to resetting the prompt, which leaves readline
440 in a messed-up state. Reset it here. */
441 observer_notify_command_error ();
442 /* This call looks bizarre, but it is required. If the user
443 entered a command that caused an error,
444 after_char_processing_hook won't be called from
445 rl_callback_read_char_wrapper. Using a cleanup there
446 won't work, since we want this function to be called
447 after a new prompt is printed. */
448 if (after_char_processing_hook
)
449 (*after_char_processing_hook
) ();
450 /* Maybe better to set a flag to be checked somewhere as to
451 whether display the prompt or not. */
457 /* We are done with the event loop. There are no more event sources
458 to listen to. So we exit GDB. */
463 /* Wrapper function for create_file_handler, so that the caller
464 doesn't have to know implementation details about the use of poll
467 add_file_handler (int fd
, handler_func
* proc
, gdb_client_data client_data
)
476 /* Check to see if poll () is usable. If not, we'll switch to
477 use select. This can happen on systems like
478 m68k-motorola-sys, `poll' cannot be used to wait for `stdin'.
479 On m68k-motorola-sysv, tty's are not stream-based and not
483 if (poll (&fds
, 1, 0) == 1 && (fds
.revents
& POLLNVAL
))
486 internal_error (__FILE__
, __LINE__
,
487 _("use_poll without HAVE_POLL"));
488 #endif /* HAVE_POLL */
493 create_file_handler (fd
, POLLIN
, proc
, client_data
);
495 internal_error (__FILE__
, __LINE__
,
496 _("use_poll without HAVE_POLL"));
500 create_file_handler (fd
, GDB_READABLE
| GDB_EXCEPTION
,
504 /* Add a file handler/descriptor to the list of descriptors we are
507 FD is the file descriptor for the file/stream to be listened to.
509 For the poll case, MASK is a combination (OR) of POLLIN,
510 POLLRDNORM, POLLRDBAND, POLLPRI, POLLOUT, POLLWRNORM, POLLWRBAND:
511 these are the events we are interested in. If any of them occurs,
512 proc should be called.
514 For the select case, MASK is a combination of READABLE, WRITABLE,
515 EXCEPTION. PROC is the procedure that will be called when an event
516 occurs for FD. CLIENT_DATA is the argument to pass to PROC. */
519 create_file_handler (int fd
, int mask
, handler_func
* proc
,
520 gdb_client_data client_data
)
522 file_handler
*file_ptr
;
524 /* Do we already have a file handler for this file? (We may be
525 changing its associated procedure). */
526 for (file_ptr
= gdb_notifier
.first_file_handler
; file_ptr
!= NULL
;
527 file_ptr
= file_ptr
->next_file
)
529 if (file_ptr
->fd
== fd
)
533 /* It is a new file descriptor. Add it to the list. Otherwise, just
534 change the data associated with it. */
535 if (file_ptr
== NULL
)
537 file_ptr
= (file_handler
*) xmalloc (sizeof (file_handler
));
539 file_ptr
->ready_mask
= 0;
540 file_ptr
->next_file
= gdb_notifier
.first_file_handler
;
541 gdb_notifier
.first_file_handler
= file_ptr
;
546 gdb_notifier
.num_fds
++;
547 if (gdb_notifier
.poll_fds
)
548 gdb_notifier
.poll_fds
=
549 (struct pollfd
*) xrealloc (gdb_notifier
.poll_fds
,
550 (gdb_notifier
.num_fds
551 * sizeof (struct pollfd
)));
553 gdb_notifier
.poll_fds
=
554 (struct pollfd
*) xmalloc (sizeof (struct pollfd
));
555 (gdb_notifier
.poll_fds
+ gdb_notifier
.num_fds
- 1)->fd
= fd
;
556 (gdb_notifier
.poll_fds
+ gdb_notifier
.num_fds
- 1)->events
= mask
;
557 (gdb_notifier
.poll_fds
+ gdb_notifier
.num_fds
- 1)->revents
= 0;
559 internal_error (__FILE__
, __LINE__
,
560 _("use_poll without HAVE_POLL"));
561 #endif /* HAVE_POLL */
565 if (mask
& GDB_READABLE
)
566 FD_SET (fd
, &gdb_notifier
.check_masks
[0]);
568 FD_CLR (fd
, &gdb_notifier
.check_masks
[0]);
570 if (mask
& GDB_WRITABLE
)
571 FD_SET (fd
, &gdb_notifier
.check_masks
[1]);
573 FD_CLR (fd
, &gdb_notifier
.check_masks
[1]);
575 if (mask
& GDB_EXCEPTION
)
576 FD_SET (fd
, &gdb_notifier
.check_masks
[2]);
578 FD_CLR (fd
, &gdb_notifier
.check_masks
[2]);
580 if (gdb_notifier
.num_fds
<= fd
)
581 gdb_notifier
.num_fds
= fd
+ 1;
585 file_ptr
->proc
= proc
;
586 file_ptr
->client_data
= client_data
;
587 file_ptr
->mask
= mask
;
590 /* Remove the file descriptor FD from the list of monitored fd's:
591 i.e. we don't care anymore about events on the FD. */
593 delete_file_handler (int fd
)
595 file_handler
*file_ptr
, *prev_ptr
= NULL
;
599 struct pollfd
*new_poll_fds
;
602 /* Find the entry for the given file. */
604 for (file_ptr
= gdb_notifier
.first_file_handler
; file_ptr
!= NULL
;
605 file_ptr
= file_ptr
->next_file
)
607 if (file_ptr
->fd
== fd
)
611 if (file_ptr
== NULL
)
617 /* Create a new poll_fds array by copying every fd's information
618 but the one we want to get rid of. */
620 new_poll_fds
= (struct pollfd
*)
621 xmalloc ((gdb_notifier
.num_fds
- 1) * sizeof (struct pollfd
));
623 for (i
= 0, j
= 0; i
< gdb_notifier
.num_fds
; i
++)
625 if ((gdb_notifier
.poll_fds
+ i
)->fd
!= fd
)
627 (new_poll_fds
+ j
)->fd
= (gdb_notifier
.poll_fds
+ i
)->fd
;
628 (new_poll_fds
+ j
)->events
= (gdb_notifier
.poll_fds
+ i
)->events
;
629 (new_poll_fds
+ j
)->revents
630 = (gdb_notifier
.poll_fds
+ i
)->revents
;
634 xfree (gdb_notifier
.poll_fds
);
635 gdb_notifier
.poll_fds
= new_poll_fds
;
636 gdb_notifier
.num_fds
--;
638 internal_error (__FILE__
, __LINE__
,
639 _("use_poll without HAVE_POLL"));
640 #endif /* HAVE_POLL */
644 if (file_ptr
->mask
& GDB_READABLE
)
645 FD_CLR (fd
, &gdb_notifier
.check_masks
[0]);
646 if (file_ptr
->mask
& GDB_WRITABLE
)
647 FD_CLR (fd
, &gdb_notifier
.check_masks
[1]);
648 if (file_ptr
->mask
& GDB_EXCEPTION
)
649 FD_CLR (fd
, &gdb_notifier
.check_masks
[2]);
651 /* Find current max fd. */
653 if ((fd
+ 1) == gdb_notifier
.num_fds
)
655 gdb_notifier
.num_fds
--;
656 for (i
= gdb_notifier
.num_fds
; i
; i
--)
658 if (FD_ISSET (i
- 1, &gdb_notifier
.check_masks
[0])
659 || FD_ISSET (i
- 1, &gdb_notifier
.check_masks
[1])
660 || FD_ISSET (i
- 1, &gdb_notifier
.check_masks
[2]))
663 gdb_notifier
.num_fds
= i
;
667 /* Deactivate the file descriptor, by clearing its mask,
668 so that it will not fire again. */
672 /* Get rid of the file handler in the file handler list. */
673 if (file_ptr
== gdb_notifier
.first_file_handler
)
674 gdb_notifier
.first_file_handler
= file_ptr
->next_file
;
677 for (prev_ptr
= gdb_notifier
.first_file_handler
;
678 prev_ptr
->next_file
!= file_ptr
;
679 prev_ptr
= prev_ptr
->next_file
)
681 prev_ptr
->next_file
= file_ptr
->next_file
;
686 /* Handle the given event by calling the procedure associated to the
687 corresponding file handler. Called by process_event indirectly,
688 through event_ptr->proc. EVENT_FILE_DESC is file descriptor of the
689 event in the front of the event queue. */
691 handle_file_event (event_data data
)
693 file_handler
*file_ptr
;
698 int event_file_desc
= data
.integer
;
700 /* Search the file handler list to find one that matches the fd in
702 for (file_ptr
= gdb_notifier
.first_file_handler
; file_ptr
!= NULL
;
703 file_ptr
= file_ptr
->next_file
)
705 if (file_ptr
->fd
== event_file_desc
)
707 /* With poll, the ready_mask could have any of three events
708 set to 1: POLLHUP, POLLERR, POLLNVAL. These events
709 cannot be used in the requested event mask (events), but
710 they can be returned in the return mask (revents). We
711 need to check for those event too, and add them to the
712 mask which will be passed to the handler. */
714 /* See if the desired events (mask) match the received
715 events (ready_mask). */
720 /* POLLHUP means EOF, but can be combined with POLLIN to
721 signal more data to read. */
722 error_mask
= POLLHUP
| POLLERR
| POLLNVAL
;
723 mask
= file_ptr
->ready_mask
& (file_ptr
->mask
| error_mask
);
725 if ((mask
& (POLLERR
| POLLNVAL
)) != 0)
727 /* Work in progress. We may need to tell somebody
728 what kind of error we had. */
730 printf_unfiltered (_("Error detected on fd %d\n"),
733 printf_unfiltered (_("Invalid or non-`poll'able fd %d\n"),
740 internal_error (__FILE__
, __LINE__
,
741 _("use_poll without HAVE_POLL"));
742 #endif /* HAVE_POLL */
746 if (file_ptr
->ready_mask
& GDB_EXCEPTION
)
748 printf_unfiltered (_("Exception condition detected "
749 "on fd %d\n"), file_ptr
->fd
);
754 mask
= file_ptr
->ready_mask
& file_ptr
->mask
;
757 /* Clear the received events for next time around. */
758 file_ptr
->ready_mask
= 0;
760 /* If there was a match, then call the handler. */
762 (*file_ptr
->proc
) (file_ptr
->error
, file_ptr
->client_data
);
768 /* Called by gdb_do_one_event to wait for new events on the monitored
769 file descriptors. Queue file events as they are detected by the
770 poll. If BLOCK and if there are no events, this function will
771 block in the call to poll. Return -1 if there are no file
772 descriptors to monitor, otherwise return 0. */
774 gdb_wait_for_event (int block
)
776 file_handler
*file_ptr
;
777 gdb_event
*file_event_ptr
;
781 /* Make sure all output is done before getting another event. */
782 gdb_flush (gdb_stdout
);
783 gdb_flush (gdb_stderr
);
785 if (gdb_notifier
.num_fds
== 0)
794 timeout
= gdb_notifier
.timeout_valid
? gdb_notifier
.poll_timeout
: -1;
798 num_found
= poll (gdb_notifier
.poll_fds
,
799 (unsigned long) gdb_notifier
.num_fds
, timeout
);
801 /* Don't print anything if we get out of poll because of a
803 if (num_found
== -1 && errno
!= EINTR
)
804 perror_with_name (("poll"));
806 internal_error (__FILE__
, __LINE__
,
807 _("use_poll without HAVE_POLL"));
808 #endif /* HAVE_POLL */
812 struct timeval select_timeout
;
813 struct timeval
*timeout_p
;
816 timeout_p
= gdb_notifier
.timeout_valid
817 ? &gdb_notifier
.select_timeout
: NULL
;
820 memset (&select_timeout
, 0, sizeof (select_timeout
));
821 timeout_p
= &select_timeout
;
824 gdb_notifier
.ready_masks
[0] = gdb_notifier
.check_masks
[0];
825 gdb_notifier
.ready_masks
[1] = gdb_notifier
.check_masks
[1];
826 gdb_notifier
.ready_masks
[2] = gdb_notifier
.check_masks
[2];
827 num_found
= gdb_select (gdb_notifier
.num_fds
,
828 &gdb_notifier
.ready_masks
[0],
829 &gdb_notifier
.ready_masks
[1],
830 &gdb_notifier
.ready_masks
[2],
833 /* Clear the masks after an error from select. */
836 FD_ZERO (&gdb_notifier
.ready_masks
[0]);
837 FD_ZERO (&gdb_notifier
.ready_masks
[1]);
838 FD_ZERO (&gdb_notifier
.ready_masks
[2]);
840 /* Dont print anything if we got a signal, let gdb handle
843 perror_with_name (("select"));
847 /* Enqueue all detected file events. */
852 for (i
= 0; (i
< gdb_notifier
.num_fds
) && (num_found
> 0); i
++)
854 if ((gdb_notifier
.poll_fds
+ i
)->revents
)
859 for (file_ptr
= gdb_notifier
.first_file_handler
;
861 file_ptr
= file_ptr
->next_file
)
863 if (file_ptr
->fd
== (gdb_notifier
.poll_fds
+ i
)->fd
)
869 /* Enqueue an event only if this is still a new event for
871 if (file_ptr
->ready_mask
== 0)
873 file_event_ptr
= create_file_event (file_ptr
->fd
);
874 QUEUE_enque (gdb_event_p
, event_queue
, file_event_ptr
);
876 file_ptr
->ready_mask
= (gdb_notifier
.poll_fds
+ i
)->revents
;
880 internal_error (__FILE__
, __LINE__
,
881 _("use_poll without HAVE_POLL"));
882 #endif /* HAVE_POLL */
886 for (file_ptr
= gdb_notifier
.first_file_handler
;
887 (file_ptr
!= NULL
) && (num_found
> 0);
888 file_ptr
= file_ptr
->next_file
)
892 if (FD_ISSET (file_ptr
->fd
, &gdb_notifier
.ready_masks
[0]))
893 mask
|= GDB_READABLE
;
894 if (FD_ISSET (file_ptr
->fd
, &gdb_notifier
.ready_masks
[1]))
895 mask
|= GDB_WRITABLE
;
896 if (FD_ISSET (file_ptr
->fd
, &gdb_notifier
.ready_masks
[2]))
897 mask
|= GDB_EXCEPTION
;
904 /* Enqueue an event only if this is still a new event for
907 if (file_ptr
->ready_mask
== 0)
909 file_event_ptr
= create_file_event (file_ptr
->fd
);
910 QUEUE_enque (gdb_event_p
, event_queue
, file_event_ptr
);
912 file_ptr
->ready_mask
= mask
;
919 /* Create an asynchronous handler, allocating memory for it.
920 Return a pointer to the newly created handler.
921 This pointer will be used to invoke the handler by
922 invoke_async_signal_handler.
923 PROC is the function to call with CLIENT_DATA argument
924 whenever the handler is invoked. */
925 async_signal_handler
*
926 create_async_signal_handler (sig_handler_func
* proc
,
927 gdb_client_data client_data
)
929 async_signal_handler
*async_handler_ptr
;
932 (async_signal_handler
*) xmalloc (sizeof (async_signal_handler
));
933 async_handler_ptr
->ready
= 0;
934 async_handler_ptr
->next_handler
= NULL
;
935 async_handler_ptr
->proc
= proc
;
936 async_handler_ptr
->client_data
= client_data
;
937 if (sighandler_list
.first_handler
== NULL
)
938 sighandler_list
.first_handler
= async_handler_ptr
;
940 sighandler_list
.last_handler
->next_handler
= async_handler_ptr
;
941 sighandler_list
.last_handler
= async_handler_ptr
;
942 return async_handler_ptr
;
945 /* Call the handler from HANDLER immediately. This function runs
946 signal handlers when returning to the event loop would be too
949 call_async_signal_handler (struct async_signal_handler
*handler
)
951 (*handler
->proc
) (handler
->client_data
);
954 /* Mark the handler (ASYNC_HANDLER_PTR) as ready. This information
955 will be used when the handlers are invoked, after we have waited
956 for some event. The caller of this function is the interrupt
957 handler associated with a signal. */
959 mark_async_signal_handler (async_signal_handler
* async_handler_ptr
)
961 async_handler_ptr
->ready
= 1;
964 /* Call all the handlers that are ready. Returns true if any was
967 invoke_async_signal_handlers (void)
969 async_signal_handler
*async_handler_ptr
;
972 /* Invoke ready handlers. */
976 for (async_handler_ptr
= sighandler_list
.first_handler
;
977 async_handler_ptr
!= NULL
;
978 async_handler_ptr
= async_handler_ptr
->next_handler
)
980 if (async_handler_ptr
->ready
)
983 if (async_handler_ptr
== NULL
)
986 async_handler_ptr
->ready
= 0;
987 (*async_handler_ptr
->proc
) (async_handler_ptr
->client_data
);
993 /* Delete an asynchronous handler (ASYNC_HANDLER_PTR).
994 Free the space allocated for it. */
996 delete_async_signal_handler (async_signal_handler
** async_handler_ptr
)
998 async_signal_handler
*prev_ptr
;
1000 if (sighandler_list
.first_handler
== (*async_handler_ptr
))
1002 sighandler_list
.first_handler
= (*async_handler_ptr
)->next_handler
;
1003 if (sighandler_list
.first_handler
== NULL
)
1004 sighandler_list
.last_handler
= NULL
;
1008 prev_ptr
= sighandler_list
.first_handler
;
1009 while (prev_ptr
&& prev_ptr
->next_handler
!= (*async_handler_ptr
))
1010 prev_ptr
= prev_ptr
->next_handler
;
1011 gdb_assert (prev_ptr
);
1012 prev_ptr
->next_handler
= (*async_handler_ptr
)->next_handler
;
1013 if (sighandler_list
.last_handler
== (*async_handler_ptr
))
1014 sighandler_list
.last_handler
= prev_ptr
;
1016 xfree ((*async_handler_ptr
));
1017 (*async_handler_ptr
) = NULL
;
1020 /* Create an asynchronous event handler, allocating memory for it.
1021 Return a pointer to the newly created handler. PROC is the
1022 function to call with CLIENT_DATA argument whenever the handler is
1024 async_event_handler
*
1025 create_async_event_handler (async_event_handler_func
*proc
,
1026 gdb_client_data client_data
)
1028 async_event_handler
*h
;
1030 h
= xmalloc (sizeof (*h
));
1032 h
->next_handler
= NULL
;
1034 h
->client_data
= client_data
;
1035 if (async_event_handler_list
.first_handler
== NULL
)
1036 async_event_handler_list
.first_handler
= h
;
1038 async_event_handler_list
.last_handler
->next_handler
= h
;
1039 async_event_handler_list
.last_handler
= h
;
1043 /* Mark the handler (ASYNC_HANDLER_PTR) as ready. This information
1044 will be used by gdb_do_one_event. The caller will be whoever
1045 created the event source, and wants to signal that the event is
1046 ready to be handled. */
1048 mark_async_event_handler (async_event_handler
*async_handler_ptr
)
1050 async_handler_ptr
->ready
= 1;
1053 struct async_event_handler_data
1055 async_event_handler_func
* proc
;
1056 gdb_client_data client_data
;
1060 invoke_async_event_handler (event_data data
)
1062 struct async_event_handler_data
*hdata
= data
.ptr
;
1063 async_event_handler_func
* proc
= hdata
->proc
;
1064 gdb_client_data client_data
= hdata
->client_data
;
1067 (*proc
) (client_data
);
1070 /* Check if any asynchronous event handlers are ready, and queue
1071 events in the ready queue for any that are. */
1073 check_async_event_handlers (void)
1075 async_event_handler
*async_handler_ptr
;
1076 struct async_event_handler_data
*hdata
;
1077 struct gdb_event
*event_ptr
;
1080 for (async_handler_ptr
= async_event_handler_list
.first_handler
;
1081 async_handler_ptr
!= NULL
;
1082 async_handler_ptr
= async_handler_ptr
->next_handler
)
1084 if (async_handler_ptr
->ready
)
1086 async_handler_ptr
->ready
= 0;
1088 hdata
= xmalloc (sizeof (*hdata
));
1090 hdata
->proc
= async_handler_ptr
->proc
;
1091 hdata
->client_data
= async_handler_ptr
->client_data
;
1095 event_ptr
= create_event (invoke_async_event_handler
, data
);
1096 QUEUE_enque (gdb_event_p
, event_queue
, event_ptr
);
1101 /* Delete an asynchronous handler (ASYNC_HANDLER_PTR).
1102 Free the space allocated for it. */
1104 delete_async_event_handler (async_event_handler
**async_handler_ptr
)
1106 async_event_handler
*prev_ptr
;
1108 if (async_event_handler_list
.first_handler
== *async_handler_ptr
)
1110 async_event_handler_list
.first_handler
1111 = (*async_handler_ptr
)->next_handler
;
1112 if (async_event_handler_list
.first_handler
== NULL
)
1113 async_event_handler_list
.last_handler
= NULL
;
1117 prev_ptr
= async_event_handler_list
.first_handler
;
1118 while (prev_ptr
&& prev_ptr
->next_handler
!= *async_handler_ptr
)
1119 prev_ptr
= prev_ptr
->next_handler
;
1120 gdb_assert (prev_ptr
);
1121 prev_ptr
->next_handler
= (*async_handler_ptr
)->next_handler
;
1122 if (async_event_handler_list
.last_handler
== (*async_handler_ptr
))
1123 async_event_handler_list
.last_handler
= prev_ptr
;
1125 xfree (*async_handler_ptr
);
1126 *async_handler_ptr
= NULL
;
1129 /* Create a timer that will expire in MILLISECONDS from now. When the
1130 timer is ready, PROC will be executed. At creation, the timer is
1131 aded to the timers queue. This queue is kept sorted in order of
1132 increasing timers. Return a handle to the timer struct. */
1134 create_timer (int milliseconds
, timer_handler_func
* proc
,
1135 gdb_client_data client_data
)
1137 struct gdb_timer
*timer_ptr
, *timer_index
, *prev_timer
;
1138 struct timeval time_now
, delta
;
1140 /* Compute seconds. */
1141 delta
.tv_sec
= milliseconds
/ 1000;
1142 /* Compute microseconds. */
1143 delta
.tv_usec
= (milliseconds
% 1000) * 1000;
1145 gettimeofday (&time_now
, NULL
);
1147 timer_ptr
= (struct gdb_timer
*) xmalloc (sizeof (*timer_ptr
));
1148 timer_ptr
->when
.tv_sec
= time_now
.tv_sec
+ delta
.tv_sec
;
1149 timer_ptr
->when
.tv_usec
= time_now
.tv_usec
+ delta
.tv_usec
;
1151 if (timer_ptr
->when
.tv_usec
>= 1000000)
1153 timer_ptr
->when
.tv_sec
+= 1;
1154 timer_ptr
->when
.tv_usec
-= 1000000;
1156 timer_ptr
->proc
= proc
;
1157 timer_ptr
->client_data
= client_data
;
1158 timer_list
.num_timers
++;
1159 timer_ptr
->timer_id
= timer_list
.num_timers
;
1161 /* Now add the timer to the timer queue, making sure it is sorted in
1162 increasing order of expiration. */
1164 for (timer_index
= timer_list
.first_timer
;
1165 timer_index
!= NULL
;
1166 timer_index
= timer_index
->next
)
1168 /* If the seconds field is greater or if it is the same, but the
1169 microsecond field is greater. */
1170 if ((timer_index
->when
.tv_sec
> timer_ptr
->when
.tv_sec
)
1171 || ((timer_index
->when
.tv_sec
== timer_ptr
->when
.tv_sec
)
1172 && (timer_index
->when
.tv_usec
> timer_ptr
->when
.tv_usec
)))
1176 if (timer_index
== timer_list
.first_timer
)
1178 timer_ptr
->next
= timer_list
.first_timer
;
1179 timer_list
.first_timer
= timer_ptr
;
1184 for (prev_timer
= timer_list
.first_timer
;
1185 prev_timer
->next
!= timer_index
;
1186 prev_timer
= prev_timer
->next
)
1189 prev_timer
->next
= timer_ptr
;
1190 timer_ptr
->next
= timer_index
;
1193 gdb_notifier
.timeout_valid
= 0;
1194 return timer_ptr
->timer_id
;
1197 /* There is a chance that the creator of the timer wants to get rid of
1198 it before it expires. */
1200 delete_timer (int id
)
1202 struct gdb_timer
*timer_ptr
, *prev_timer
= NULL
;
1204 /* Find the entry for the given timer. */
1206 for (timer_ptr
= timer_list
.first_timer
; timer_ptr
!= NULL
;
1207 timer_ptr
= timer_ptr
->next
)
1209 if (timer_ptr
->timer_id
== id
)
1213 if (timer_ptr
== NULL
)
1215 /* Get rid of the timer in the timer list. */
1216 if (timer_ptr
== timer_list
.first_timer
)
1217 timer_list
.first_timer
= timer_ptr
->next
;
1220 for (prev_timer
= timer_list
.first_timer
;
1221 prev_timer
->next
!= timer_ptr
;
1222 prev_timer
= prev_timer
->next
)
1224 prev_timer
->next
= timer_ptr
->next
;
1228 gdb_notifier
.timeout_valid
= 0;
1231 /* When a timer event is put on the event queue, it will be handled by
1232 this function. Just call the associated procedure and delete the
1233 timer event from the event queue. Repeat this for each timer that
1236 handle_timer_event (event_data dummy
)
1238 struct timeval time_now
;
1239 struct gdb_timer
*timer_ptr
, *saved_timer
;
1241 gettimeofday (&time_now
, NULL
);
1242 timer_ptr
= timer_list
.first_timer
;
1244 while (timer_ptr
!= NULL
)
1246 if ((timer_ptr
->when
.tv_sec
> time_now
.tv_sec
)
1247 || ((timer_ptr
->when
.tv_sec
== time_now
.tv_sec
)
1248 && (timer_ptr
->when
.tv_usec
> time_now
.tv_usec
)))
1251 /* Get rid of the timer from the beginning of the list. */
1252 timer_list
.first_timer
= timer_ptr
->next
;
1253 saved_timer
= timer_ptr
;
1254 timer_ptr
= timer_ptr
->next
;
1255 /* Call the procedure associated with that timer. */
1256 (*saved_timer
->proc
) (saved_timer
->client_data
);
1257 xfree (saved_timer
);
1260 gdb_notifier
.timeout_valid
= 0;
1263 /* Check whether any timers in the timers queue are ready. If at least
1264 one timer is ready, stick an event onto the event queue. Even in
1265 case more than one timer is ready, one event is enough, because the
1266 handle_timer_event() will go through the timers list and call the
1267 procedures associated with all that have expired.l Update the
1268 timeout for the select() or poll() as well. */
1272 struct timeval time_now
, delta
;
1273 gdb_event
*event_ptr
;
1275 if (timer_list
.first_timer
!= NULL
)
1277 gettimeofday (&time_now
, NULL
);
1278 delta
.tv_sec
= timer_list
.first_timer
->when
.tv_sec
- time_now
.tv_sec
;
1279 delta
.tv_usec
= timer_list
.first_timer
->when
.tv_usec
- time_now
.tv_usec
;
1281 if (delta
.tv_usec
< 0)
1284 delta
.tv_usec
+= 1000000;
1287 /* Oops it expired already. Tell select / poll to return
1288 immediately. (Cannot simply test if delta.tv_sec is negative
1289 because time_t might be unsigned.) */
1290 if (timer_list
.first_timer
->when
.tv_sec
< time_now
.tv_sec
1291 || (timer_list
.first_timer
->when
.tv_sec
== time_now
.tv_sec
1292 && timer_list
.first_timer
->when
.tv_usec
< time_now
.tv_usec
))
1298 if (delta
.tv_sec
== 0 && delta
.tv_usec
== 0)
1300 event_ptr
= (gdb_event
*) xmalloc (sizeof (gdb_event
));
1301 event_ptr
->proc
= handle_timer_event
;
1302 event_ptr
->data
.integer
= timer_list
.first_timer
->timer_id
;
1303 QUEUE_enque (gdb_event_p
, event_queue
, event_ptr
);
1306 /* Now we need to update the timeout for select/ poll, because
1307 we don't want to sit there while this timer is expiring. */
1311 gdb_notifier
.poll_timeout
= delta
.tv_sec
* 1000;
1313 internal_error (__FILE__
, __LINE__
,
1314 _("use_poll without HAVE_POLL"));
1315 #endif /* HAVE_POLL */
1319 gdb_notifier
.select_timeout
.tv_sec
= delta
.tv_sec
;
1320 gdb_notifier
.select_timeout
.tv_usec
= delta
.tv_usec
;
1322 gdb_notifier
.timeout_valid
= 1;
1325 gdb_notifier
.timeout_valid
= 0;