1 /* Event loop machinery for GDB, the GNU debugger.
2 Copyright (C) 1999-2013 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"
25 #if defined (HAVE_POLL_H)
27 #elif defined (HAVE_SYS_POLL_H)
32 #include <sys/types.h>
33 #include "gdb_string.h"
36 #include "exceptions.h"
37 #include "gdb_assert.h"
38 #include "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 /* Data point to pass to the event handler. */
48 typedef union event_data
54 typedef struct gdb_event gdb_event
;
55 typedef void (event_handler_func
) (event_data
);
57 /* Event for the GDB event system. Events are queued by calling
58 async_queue_event and serviced later on by gdb_do_one_event. An
59 event can be, for instance, a file descriptor becoming ready to be
60 read. Servicing an event simply means that the procedure PROC will
61 be called. We have 2 queues, one for file handlers that we listen
62 to in the event loop, and one for the file handlers+events that are
63 ready. The procedure PROC associated with each event is dependant
64 of the event source. In the case of monitored file descriptors, it
65 is always the same (handle_file_event). Its duty is to invoke the
66 handler associated with the file descriptor whose state change
67 generated the event, plus doing other cleanups and such. In the
68 case of async signal handlers, it is
69 invoke_async_signal_handler. */
73 /* Procedure to call to service this event. */
74 event_handler_func
*proc
;
76 /* Data to pass to the event handler. */
79 /* Next in list of events or NULL. */
80 struct gdb_event
*next_event
;
83 /* Information about each file descriptor we register with the event
86 typedef struct file_handler
88 int fd
; /* File descriptor. */
89 int mask
; /* Events we want to monitor: POLLIN, etc. */
90 int ready_mask
; /* Events that have been seen since
92 handler_func
*proc
; /* Procedure to call when fd is ready. */
93 gdb_client_data client_data
; /* Argument to pass to proc. */
94 int error
; /* Was an error detected on this fd? */
95 struct file_handler
*next_file
; /* Next registered file descriptor. */
99 /* PROC is a function to be invoked when the READY flag is set. This
100 happens when there has been a signal and the corresponding signal
101 handler has 'triggered' this async_signal_handler for execution.
102 The actual work to be done in response to a signal will be carried
103 out by PROC at a later time, within process_event. This provides a
104 deferred execution of signal handlers.
106 Async_init_signals takes care of setting up such an
107 async_signal_handler for each interesting signal. */
109 typedef struct async_signal_handler
111 int ready
; /* If ready, call this handler
112 from the main event loop, using
113 invoke_async_handler. */
114 struct async_signal_handler
*next_handler
; /* Ptr to next handler. */
115 sig_handler_func
*proc
; /* Function to call to do the work. */
116 gdb_client_data client_data
; /* Argument to async_handler_func. */
118 async_signal_handler
;
120 /* PROC is a function to be invoked when the READY flag is set. This
121 happens when the event has been marked with
122 MARK_ASYNC_EVENT_HANDLER. The actual work to be done in response
123 to an event will be carried out by PROC at a later time, within
124 process_event. This provides a deferred execution of event
126 typedef struct async_event_handler
128 /* If ready, call this handler from the main event loop, using
129 invoke_event_handler. */
132 /* Point to next handler. */
133 struct async_event_handler
*next_handler
;
135 /* Function to call to do the work. */
136 async_event_handler_func
*proc
;
138 /* Argument to PROC. */
139 gdb_client_data client_data
;
145 - the first event in the queue is the head of the queue.
146 It will be the next to be serviced.
147 - the last event in the queue
149 Events can be inserted at the front of the queue or at the end of
150 the queue. Events will be extracted from the queue for processing
151 starting from the head. Therefore, events inserted at the head of
152 the queue will be processed in a last in first out fashion, while
153 those inserted at the tail of the queue will be processed in a first
154 in first out manner. All the fields are NULL if the queue is
159 gdb_event
*first_event
; /* First pending event. */
160 gdb_event
*last_event
; /* Last pending event. */
164 /* Gdb_notifier is just a list of file descriptors gdb is interested in.
165 These are the input file descriptor, and the target file
166 descriptor. We have two flavors of the notifier, one for platforms
167 that have the POLL function, the other for those that don't, and
168 only support SELECT. Each of the elements in the gdb_notifier list is
169 basically a description of what kind of events gdb is interested
172 /* As of 1999-04-30 only the input file descriptor is registered with the
175 /* Do we use poll or select ? */
180 #endif /* HAVE_POLL */
182 static unsigned char use_poll
= USE_POLL
;
191 /* Ptr to head of file handler list. */
192 file_handler
*first_file_handler
;
195 /* Ptr to array of pollfd structures. */
196 struct pollfd
*poll_fds
;
198 /* Timeout in milliseconds for calls to poll(). */
202 /* Masks to be used in the next call to select.
203 Bits are set in response to calls to create_file_handler. */
204 fd_set check_masks
[3];
206 /* What file descriptors were found ready by select. */
207 fd_set ready_masks
[3];
209 /* Number of file descriptors to monitor (for poll). */
210 /* Number of valid bits (highest fd value + 1) (for select). */
213 /* Time structure for calls to select(). */
214 struct timeval select_timeout
;
216 /* Flag to tell whether the timeout should be used. */
221 /* Structure associated with a timer. PROC will be executed at the
222 first occasion after WHEN. */
227 struct gdb_timer
*next
;
228 timer_handler_func
*proc
; /* Function to call to do the work. */
229 gdb_client_data client_data
; /* Argument to async_handler_func. */
232 /* List of currently active timers. It is sorted in order of
233 increasing timers. */
236 /* Pointer to first in timer list. */
237 struct gdb_timer
*first_timer
;
239 /* Id of the last timer created. */
244 /* All the async_signal_handlers gdb is interested in are kept onto
248 /* Pointer to first in handler list. */
249 async_signal_handler
*first_handler
;
251 /* Pointer to last in handler list. */
252 async_signal_handler
*last_handler
;
256 /* All the async_event_handlers gdb is interested in are kept onto
260 /* Pointer to first in handler list. */
261 async_event_handler
*first_handler
;
263 /* Pointer to last in handler list. */
264 async_event_handler
*last_handler
;
266 async_event_handler_list
;
268 static int invoke_async_signal_handlers (void);
269 static void create_file_handler (int fd
, int mask
, handler_func
*proc
,
270 gdb_client_data client_data
);
271 static void handle_file_event (event_data data
);
272 static void check_async_event_handlers (void);
273 static int gdb_wait_for_event (int);
274 static void poll_timers (void);
277 /* Insert an event object into the gdb event queue.
278 EVENT_PTR points to the event to be inserted into the queue.
279 The caller must allocate memory for the event. It is freed
280 after the event has ben handled.
281 Events in the queue will be processed head to tail, therefore,
282 events inserted at the head of the queue will be processed
283 as last in first out. Event appended at the tail of the queue
284 will be processed first in first out. */
286 async_queue_event (gdb_event
* event_ptr
)
288 /* The event will become the new last_event. */
290 event_ptr
->next_event
= NULL
;
291 if (event_queue
.first_event
== NULL
)
292 event_queue
.first_event
= event_ptr
;
294 event_queue
.last_event
->next_event
= event_ptr
;
295 event_queue
.last_event
= event_ptr
;
298 /* Create a generic event, to be enqueued in the event queue for
299 processing. PROC is the procedure associated to the event. DATA
300 is passed to PROC upon PROC invocation. */
303 create_event (event_handler_func proc
, event_data data
)
307 event
= xmalloc (sizeof (*event
));
314 /* Create a file event, to be enqueued in the event queue for
315 processing. The procedure associated to this event is always
316 handle_file_event, which will in turn invoke the one that was
317 associated to FD when it was registered with the event loop. */
319 create_file_event (int fd
)
324 return create_event (handle_file_event
, data
);
327 /* Process one event.
328 The event can be the next one to be serviced in the event queue,
329 or an asynchronous event handler can be invoked in response to
330 the reception of a signal.
331 If an event was processed (either way), 1 is returned otherwise
333 Scan the queue from head to tail, processing therefore the high
334 priority events first, by invoking the associated event handler
339 gdb_event
*event_ptr
, *prev_ptr
;
340 event_handler_func
*proc
;
343 /* First let's see if there are any asynchronous event handlers that
344 are ready. These would be the result of invoking any of the
347 if (invoke_async_signal_handlers ())
350 /* Look in the event queue to find an event that is ready
353 for (event_ptr
= event_queue
.first_event
; event_ptr
!= NULL
;
354 event_ptr
= event_ptr
->next_event
)
356 /* Call the handler for the event. */
358 proc
= event_ptr
->proc
;
359 data
= event_ptr
->data
;
361 /* Let's get rid of the event from the event queue. We need to
362 do this now because while processing the event, the proc
363 function could end up calling 'error' and therefore jump out
364 to the caller of this function, gdb_do_one_event. In that
365 case, we would have on the event queue an event wich has been
366 processed, but not deleted. */
368 if (event_queue
.first_event
== event_ptr
)
370 event_queue
.first_event
= event_ptr
->next_event
;
371 if (event_ptr
->next_event
== NULL
)
372 event_queue
.last_event
= NULL
;
376 prev_ptr
= event_queue
.first_event
;
377 while (prev_ptr
->next_event
!= event_ptr
)
378 prev_ptr
= prev_ptr
->next_event
;
380 prev_ptr
->next_event
= event_ptr
->next_event
;
381 if (event_ptr
->next_event
== NULL
)
382 event_queue
.last_event
= prev_ptr
;
386 /* Now call the procedure associated with the event. */
391 /* This is the case if there are no event on the event queue. */
395 /* Process one high level event. If nothing is ready at this time,
396 wait for something to happen (via gdb_wait_for_event), then process
397 it. Returns >0 if something was done otherwise returns <0 (this
398 can happen if there are no event sources to wait for). */
401 gdb_do_one_event (void)
403 static int event_source_head
= 0;
404 const int number_of_sources
= 3;
407 /* Any events already waiting in the queue? */
408 if (process_event ())
411 /* To level the fairness across event sources, we poll them in a
412 round-robin fashion. */
413 for (current
= 0; current
< number_of_sources
; current
++)
415 switch (event_source_head
)
418 /* Are any timers that are ready? If so, put an event on the
423 /* Are there events already waiting to be collected on the
424 monitored file descriptors? */
425 gdb_wait_for_event (0);
428 /* Are there any asynchronous event handlers ready? */
429 check_async_event_handlers ();
434 if (event_source_head
== number_of_sources
)
435 event_source_head
= 0;
438 /* Handle any new events collected. */
439 if (process_event ())
442 /* Block waiting for a new event. If gdb_wait_for_event returns -1,
443 we should get out because this means that there are no event
444 sources left. This will make the event loop stop, and the
447 if (gdb_wait_for_event (1) < 0)
450 /* Handle any new events occurred while waiting. */
451 if (process_event ())
454 /* If gdb_wait_for_event has returned 1, it means that one event has
455 been handled. We break out of the loop. */
459 /* Start up the event loop. This is the entry point to the event loop
460 from the command loop. */
463 start_event_loop (void)
465 /* Loop until there is nothing to do. This is the entry point to
466 the event loop engine. gdb_do_one_event will process one event
467 for each invocation. It blocks waiting for an event and then
471 volatile struct gdb_exception ex
;
474 TRY_CATCH (ex
, RETURN_MASK_ALL
)
476 result
= gdb_do_one_event ();
480 exception_print (gdb_stderr
, ex
);
482 /* If any exception escaped to here, we better enable
483 stdin. Otherwise, any command that calls async_disable_stdin,
484 and then throws, will leave stdin inoperable. */
485 async_enable_stdin ();
486 /* If we long-jumped out of do_one_event, we probably didn't
487 get around to resetting the prompt, which leaves readline
488 in a messed-up state. Reset it here. */
489 /* FIXME: this should really be a call to a hook that is
490 interface specific, because interfaces can display the
491 prompt in their own way. */
492 display_gdb_prompt (0);
493 /* This call looks bizarre, but it is required. If the user
494 entered a command that caused an error,
495 after_char_processing_hook won't be called from
496 rl_callback_read_char_wrapper. Using a cleanup there
497 won't work, since we want this function to be called
498 after a new prompt is printed. */
499 if (after_char_processing_hook
)
500 (*after_char_processing_hook
) ();
501 /* Maybe better to set a flag to be checked somewhere as to
502 whether display the prompt or not. */
508 /* We are done with the event loop. There are no more event sources
509 to listen to. So we exit GDB. */
514 /* Wrapper function for create_file_handler, so that the caller
515 doesn't have to know implementation details about the use of poll
518 add_file_handler (int fd
, handler_func
* proc
, gdb_client_data client_data
)
527 /* Check to see if poll () is usable. If not, we'll switch to
528 use select. This can happen on systems like
529 m68k-motorola-sys, `poll' cannot be used to wait for `stdin'.
530 On m68k-motorola-sysv, tty's are not stream-based and not
534 if (poll (&fds
, 1, 0) == 1 && (fds
.revents
& POLLNVAL
))
537 internal_error (__FILE__
, __LINE__
,
538 _("use_poll without HAVE_POLL"));
539 #endif /* HAVE_POLL */
544 create_file_handler (fd
, POLLIN
, proc
, client_data
);
546 internal_error (__FILE__
, __LINE__
,
547 _("use_poll without HAVE_POLL"));
551 create_file_handler (fd
, GDB_READABLE
| GDB_EXCEPTION
,
555 /* Add a file handler/descriptor to the list of descriptors we are
558 FD is the file descriptor for the file/stream to be listened to.
560 For the poll case, MASK is a combination (OR) of POLLIN,
561 POLLRDNORM, POLLRDBAND, POLLPRI, POLLOUT, POLLWRNORM, POLLWRBAND:
562 these are the events we are interested in. If any of them occurs,
563 proc should be called.
565 For the select case, MASK is a combination of READABLE, WRITABLE,
566 EXCEPTION. PROC is the procedure that will be called when an event
567 occurs for FD. CLIENT_DATA is the argument to pass to PROC. */
570 create_file_handler (int fd
, int mask
, handler_func
* proc
,
571 gdb_client_data client_data
)
573 file_handler
*file_ptr
;
575 /* Do we already have a file handler for this file? (We may be
576 changing its associated procedure). */
577 for (file_ptr
= gdb_notifier
.first_file_handler
; file_ptr
!= NULL
;
578 file_ptr
= file_ptr
->next_file
)
580 if (file_ptr
->fd
== fd
)
584 /* It is a new file descriptor. Add it to the list. Otherwise, just
585 change the data associated with it. */
586 if (file_ptr
== NULL
)
588 file_ptr
= (file_handler
*) xmalloc (sizeof (file_handler
));
590 file_ptr
->ready_mask
= 0;
591 file_ptr
->next_file
= gdb_notifier
.first_file_handler
;
592 gdb_notifier
.first_file_handler
= file_ptr
;
597 gdb_notifier
.num_fds
++;
598 if (gdb_notifier
.poll_fds
)
599 gdb_notifier
.poll_fds
=
600 (struct pollfd
*) xrealloc (gdb_notifier
.poll_fds
,
601 (gdb_notifier
.num_fds
602 * sizeof (struct pollfd
)));
604 gdb_notifier
.poll_fds
=
605 (struct pollfd
*) xmalloc (sizeof (struct pollfd
));
606 (gdb_notifier
.poll_fds
+ gdb_notifier
.num_fds
- 1)->fd
= fd
;
607 (gdb_notifier
.poll_fds
+ gdb_notifier
.num_fds
- 1)->events
= mask
;
608 (gdb_notifier
.poll_fds
+ gdb_notifier
.num_fds
- 1)->revents
= 0;
610 internal_error (__FILE__
, __LINE__
,
611 _("use_poll without HAVE_POLL"));
612 #endif /* HAVE_POLL */
616 if (mask
& GDB_READABLE
)
617 FD_SET (fd
, &gdb_notifier
.check_masks
[0]);
619 FD_CLR (fd
, &gdb_notifier
.check_masks
[0]);
621 if (mask
& GDB_WRITABLE
)
622 FD_SET (fd
, &gdb_notifier
.check_masks
[1]);
624 FD_CLR (fd
, &gdb_notifier
.check_masks
[1]);
626 if (mask
& GDB_EXCEPTION
)
627 FD_SET (fd
, &gdb_notifier
.check_masks
[2]);
629 FD_CLR (fd
, &gdb_notifier
.check_masks
[2]);
631 if (gdb_notifier
.num_fds
<= fd
)
632 gdb_notifier
.num_fds
= fd
+ 1;
636 file_ptr
->proc
= proc
;
637 file_ptr
->client_data
= client_data
;
638 file_ptr
->mask
= mask
;
641 /* Remove the file descriptor FD from the list of monitored fd's:
642 i.e. we don't care anymore about events on the FD. */
644 delete_file_handler (int fd
)
646 file_handler
*file_ptr
, *prev_ptr
= NULL
;
650 struct pollfd
*new_poll_fds
;
653 /* Find the entry for the given file. */
655 for (file_ptr
= gdb_notifier
.first_file_handler
; file_ptr
!= NULL
;
656 file_ptr
= file_ptr
->next_file
)
658 if (file_ptr
->fd
== fd
)
662 if (file_ptr
== NULL
)
668 /* Create a new poll_fds array by copying every fd's information
669 but the one we want to get rid of. */
671 new_poll_fds
= (struct pollfd
*)
672 xmalloc ((gdb_notifier
.num_fds
- 1) * sizeof (struct pollfd
));
674 for (i
= 0, j
= 0; i
< gdb_notifier
.num_fds
; i
++)
676 if ((gdb_notifier
.poll_fds
+ i
)->fd
!= fd
)
678 (new_poll_fds
+ j
)->fd
= (gdb_notifier
.poll_fds
+ i
)->fd
;
679 (new_poll_fds
+ j
)->events
= (gdb_notifier
.poll_fds
+ i
)->events
;
680 (new_poll_fds
+ j
)->revents
681 = (gdb_notifier
.poll_fds
+ i
)->revents
;
685 xfree (gdb_notifier
.poll_fds
);
686 gdb_notifier
.poll_fds
= new_poll_fds
;
687 gdb_notifier
.num_fds
--;
689 internal_error (__FILE__
, __LINE__
,
690 _("use_poll without HAVE_POLL"));
691 #endif /* HAVE_POLL */
695 if (file_ptr
->mask
& GDB_READABLE
)
696 FD_CLR (fd
, &gdb_notifier
.check_masks
[0]);
697 if (file_ptr
->mask
& GDB_WRITABLE
)
698 FD_CLR (fd
, &gdb_notifier
.check_masks
[1]);
699 if (file_ptr
->mask
& GDB_EXCEPTION
)
700 FD_CLR (fd
, &gdb_notifier
.check_masks
[2]);
702 /* Find current max fd. */
704 if ((fd
+ 1) == gdb_notifier
.num_fds
)
706 gdb_notifier
.num_fds
--;
707 for (i
= gdb_notifier
.num_fds
; i
; i
--)
709 if (FD_ISSET (i
- 1, &gdb_notifier
.check_masks
[0])
710 || FD_ISSET (i
- 1, &gdb_notifier
.check_masks
[1])
711 || FD_ISSET (i
- 1, &gdb_notifier
.check_masks
[2]))
714 gdb_notifier
.num_fds
= i
;
718 /* Deactivate the file descriptor, by clearing its mask,
719 so that it will not fire again. */
723 /* Get rid of the file handler in the file handler list. */
724 if (file_ptr
== gdb_notifier
.first_file_handler
)
725 gdb_notifier
.first_file_handler
= file_ptr
->next_file
;
728 for (prev_ptr
= gdb_notifier
.first_file_handler
;
729 prev_ptr
->next_file
!= file_ptr
;
730 prev_ptr
= prev_ptr
->next_file
)
732 prev_ptr
->next_file
= file_ptr
->next_file
;
737 /* Handle the given event by calling the procedure associated to the
738 corresponding file handler. Called by process_event indirectly,
739 through event_ptr->proc. EVENT_FILE_DESC is file descriptor of the
740 event in the front of the event queue. */
742 handle_file_event (event_data data
)
744 file_handler
*file_ptr
;
749 int event_file_desc
= data
.integer
;
751 /* Search the file handler list to find one that matches the fd in
753 for (file_ptr
= gdb_notifier
.first_file_handler
; file_ptr
!= NULL
;
754 file_ptr
= file_ptr
->next_file
)
756 if (file_ptr
->fd
== event_file_desc
)
758 /* With poll, the ready_mask could have any of three events
759 set to 1: POLLHUP, POLLERR, POLLNVAL. These events
760 cannot be used in the requested event mask (events), but
761 they can be returned in the return mask (revents). We
762 need to check for those event too, and add them to the
763 mask which will be passed to the handler. */
765 /* See if the desired events (mask) match the received
766 events (ready_mask). */
771 /* POLLHUP means EOF, but can be combined with POLLIN to
772 signal more data to read. */
773 error_mask
= POLLHUP
| POLLERR
| POLLNVAL
;
774 mask
= file_ptr
->ready_mask
& (file_ptr
->mask
| error_mask
);
776 if ((mask
& (POLLERR
| POLLNVAL
)) != 0)
778 /* Work in progress. We may need to tell somebody
779 what kind of error we had. */
781 printf_unfiltered (_("Error detected on fd %d\n"),
784 printf_unfiltered (_("Invalid or non-`poll'able fd %d\n"),
791 internal_error (__FILE__
, __LINE__
,
792 _("use_poll without HAVE_POLL"));
793 #endif /* HAVE_POLL */
797 if (file_ptr
->ready_mask
& GDB_EXCEPTION
)
799 printf_unfiltered (_("Exception condition detected "
800 "on fd %d\n"), file_ptr
->fd
);
805 mask
= file_ptr
->ready_mask
& file_ptr
->mask
;
808 /* Clear the received events for next time around. */
809 file_ptr
->ready_mask
= 0;
811 /* If there was a match, then call the handler. */
813 (*file_ptr
->proc
) (file_ptr
->error
, file_ptr
->client_data
);
819 /* Called by gdb_do_one_event to wait for new events on the monitored
820 file descriptors. Queue file events as they are detected by the
821 poll. If BLOCK and if there are no events, this function will
822 block in the call to poll. Return -1 if there are no file
823 descriptors to monitor, otherwise return 0. */
825 gdb_wait_for_event (int block
)
827 file_handler
*file_ptr
;
828 gdb_event
*file_event_ptr
;
832 /* Make sure all output is done before getting another event. */
833 gdb_flush (gdb_stdout
);
834 gdb_flush (gdb_stderr
);
836 if (gdb_notifier
.num_fds
== 0)
845 timeout
= gdb_notifier
.timeout_valid
? gdb_notifier
.poll_timeout
: -1;
849 num_found
= poll (gdb_notifier
.poll_fds
,
850 (unsigned long) gdb_notifier
.num_fds
, timeout
);
852 /* Don't print anything if we get out of poll because of a
854 if (num_found
== -1 && errno
!= EINTR
)
855 perror_with_name (("poll"));
857 internal_error (__FILE__
, __LINE__
,
858 _("use_poll without HAVE_POLL"));
859 #endif /* HAVE_POLL */
863 struct timeval select_timeout
;
864 struct timeval
*timeout_p
;
867 timeout_p
= gdb_notifier
.timeout_valid
868 ? &gdb_notifier
.select_timeout
: NULL
;
871 memset (&select_timeout
, 0, sizeof (select_timeout
));
872 timeout_p
= &select_timeout
;
875 gdb_notifier
.ready_masks
[0] = gdb_notifier
.check_masks
[0];
876 gdb_notifier
.ready_masks
[1] = gdb_notifier
.check_masks
[1];
877 gdb_notifier
.ready_masks
[2] = gdb_notifier
.check_masks
[2];
878 num_found
= gdb_select (gdb_notifier
.num_fds
,
879 &gdb_notifier
.ready_masks
[0],
880 &gdb_notifier
.ready_masks
[1],
881 &gdb_notifier
.ready_masks
[2],
884 /* Clear the masks after an error from select. */
887 FD_ZERO (&gdb_notifier
.ready_masks
[0]);
888 FD_ZERO (&gdb_notifier
.ready_masks
[1]);
889 FD_ZERO (&gdb_notifier
.ready_masks
[2]);
891 /* Dont print anything if we got a signal, let gdb handle
894 perror_with_name (("select"));
898 /* Enqueue all detected file events. */
903 for (i
= 0; (i
< gdb_notifier
.num_fds
) && (num_found
> 0); i
++)
905 if ((gdb_notifier
.poll_fds
+ i
)->revents
)
910 for (file_ptr
= gdb_notifier
.first_file_handler
;
912 file_ptr
= file_ptr
->next_file
)
914 if (file_ptr
->fd
== (gdb_notifier
.poll_fds
+ i
)->fd
)
920 /* Enqueue an event only if this is still a new event for
922 if (file_ptr
->ready_mask
== 0)
924 file_event_ptr
= create_file_event (file_ptr
->fd
);
925 async_queue_event (file_event_ptr
);
927 file_ptr
->ready_mask
= (gdb_notifier
.poll_fds
+ i
)->revents
;
931 internal_error (__FILE__
, __LINE__
,
932 _("use_poll without HAVE_POLL"));
933 #endif /* HAVE_POLL */
937 for (file_ptr
= gdb_notifier
.first_file_handler
;
938 (file_ptr
!= NULL
) && (num_found
> 0);
939 file_ptr
= file_ptr
->next_file
)
943 if (FD_ISSET (file_ptr
->fd
, &gdb_notifier
.ready_masks
[0]))
944 mask
|= GDB_READABLE
;
945 if (FD_ISSET (file_ptr
->fd
, &gdb_notifier
.ready_masks
[1]))
946 mask
|= GDB_WRITABLE
;
947 if (FD_ISSET (file_ptr
->fd
, &gdb_notifier
.ready_masks
[2]))
948 mask
|= GDB_EXCEPTION
;
955 /* Enqueue an event only if this is still a new event for
958 if (file_ptr
->ready_mask
== 0)
960 file_event_ptr
= create_file_event (file_ptr
->fd
);
961 async_queue_event (file_event_ptr
);
963 file_ptr
->ready_mask
= mask
;
970 /* Create an asynchronous handler, allocating memory for it.
971 Return a pointer to the newly created handler.
972 This pointer will be used to invoke the handler by
973 invoke_async_signal_handler.
974 PROC is the function to call with CLIENT_DATA argument
975 whenever the handler is invoked. */
976 async_signal_handler
*
977 create_async_signal_handler (sig_handler_func
* proc
,
978 gdb_client_data client_data
)
980 async_signal_handler
*async_handler_ptr
;
983 (async_signal_handler
*) xmalloc (sizeof (async_signal_handler
));
984 async_handler_ptr
->ready
= 0;
985 async_handler_ptr
->next_handler
= NULL
;
986 async_handler_ptr
->proc
= proc
;
987 async_handler_ptr
->client_data
= client_data
;
988 if (sighandler_list
.first_handler
== NULL
)
989 sighandler_list
.first_handler
= async_handler_ptr
;
991 sighandler_list
.last_handler
->next_handler
= async_handler_ptr
;
992 sighandler_list
.last_handler
= async_handler_ptr
;
993 return async_handler_ptr
;
996 /* Call the handler from HANDLER immediately. This function runs
997 signal handlers when returning to the event loop would be too
1000 call_async_signal_handler (struct async_signal_handler
*handler
)
1002 (*handler
->proc
) (handler
->client_data
);
1005 /* Mark the handler (ASYNC_HANDLER_PTR) as ready. This information
1006 will be used when the handlers are invoked, after we have waited
1007 for some event. The caller of this function is the interrupt
1008 handler associated with a signal. */
1010 mark_async_signal_handler (async_signal_handler
* async_handler_ptr
)
1012 async_handler_ptr
->ready
= 1;
1015 /* Call all the handlers that are ready. Returns true if any was
1018 invoke_async_signal_handlers (void)
1020 async_signal_handler
*async_handler_ptr
;
1023 /* Invoke ready handlers. */
1027 for (async_handler_ptr
= sighandler_list
.first_handler
;
1028 async_handler_ptr
!= NULL
;
1029 async_handler_ptr
= async_handler_ptr
->next_handler
)
1031 if (async_handler_ptr
->ready
)
1034 if (async_handler_ptr
== NULL
)
1037 async_handler_ptr
->ready
= 0;
1038 (*async_handler_ptr
->proc
) (async_handler_ptr
->client_data
);
1044 /* Delete an asynchronous handler (ASYNC_HANDLER_PTR).
1045 Free the space allocated for it. */
1047 delete_async_signal_handler (async_signal_handler
** async_handler_ptr
)
1049 async_signal_handler
*prev_ptr
;
1051 if (sighandler_list
.first_handler
== (*async_handler_ptr
))
1053 sighandler_list
.first_handler
= (*async_handler_ptr
)->next_handler
;
1054 if (sighandler_list
.first_handler
== NULL
)
1055 sighandler_list
.last_handler
= NULL
;
1059 prev_ptr
= sighandler_list
.first_handler
;
1060 while (prev_ptr
&& prev_ptr
->next_handler
!= (*async_handler_ptr
))
1061 prev_ptr
= prev_ptr
->next_handler
;
1062 gdb_assert (prev_ptr
);
1063 prev_ptr
->next_handler
= (*async_handler_ptr
)->next_handler
;
1064 if (sighandler_list
.last_handler
== (*async_handler_ptr
))
1065 sighandler_list
.last_handler
= prev_ptr
;
1067 xfree ((*async_handler_ptr
));
1068 (*async_handler_ptr
) = NULL
;
1071 /* Create an asynchronous event handler, allocating memory for it.
1072 Return a pointer to the newly created handler. PROC is the
1073 function to call with CLIENT_DATA argument whenever the handler is
1075 async_event_handler
*
1076 create_async_event_handler (async_event_handler_func
*proc
,
1077 gdb_client_data client_data
)
1079 async_event_handler
*h
;
1081 h
= xmalloc (sizeof (*h
));
1083 h
->next_handler
= NULL
;
1085 h
->client_data
= client_data
;
1086 if (async_event_handler_list
.first_handler
== NULL
)
1087 async_event_handler_list
.first_handler
= h
;
1089 async_event_handler_list
.last_handler
->next_handler
= h
;
1090 async_event_handler_list
.last_handler
= h
;
1094 /* Mark the handler (ASYNC_HANDLER_PTR) as ready. This information
1095 will be used by gdb_do_one_event. The caller will be whoever
1096 created the event source, and wants to signal that the event is
1097 ready to be handled. */
1099 mark_async_event_handler (async_event_handler
*async_handler_ptr
)
1101 async_handler_ptr
->ready
= 1;
1104 struct async_event_handler_data
1106 async_event_handler_func
* proc
;
1107 gdb_client_data client_data
;
1111 invoke_async_event_handler (event_data data
)
1113 struct async_event_handler_data
*hdata
= data
.ptr
;
1114 async_event_handler_func
* proc
= hdata
->proc
;
1115 gdb_client_data client_data
= hdata
->client_data
;
1118 (*proc
) (client_data
);
1121 /* Check if any asynchronous event handlers are ready, and queue
1122 events in the ready queue for any that are. */
1124 check_async_event_handlers (void)
1126 async_event_handler
*async_handler_ptr
;
1127 struct async_event_handler_data
*hdata
;
1128 struct gdb_event
*event_ptr
;
1131 for (async_handler_ptr
= async_event_handler_list
.first_handler
;
1132 async_handler_ptr
!= NULL
;
1133 async_handler_ptr
= async_handler_ptr
->next_handler
)
1135 if (async_handler_ptr
->ready
)
1137 async_handler_ptr
->ready
= 0;
1139 hdata
= xmalloc (sizeof (*hdata
));
1141 hdata
->proc
= async_handler_ptr
->proc
;
1142 hdata
->client_data
= async_handler_ptr
->client_data
;
1146 event_ptr
= create_event (invoke_async_event_handler
, data
);
1147 async_queue_event (event_ptr
);
1152 /* Delete an asynchronous handler (ASYNC_HANDLER_PTR).
1153 Free the space allocated for it. */
1155 delete_async_event_handler (async_event_handler
**async_handler_ptr
)
1157 async_event_handler
*prev_ptr
;
1159 if (async_event_handler_list
.first_handler
== *async_handler_ptr
)
1161 async_event_handler_list
.first_handler
1162 = (*async_handler_ptr
)->next_handler
;
1163 if (async_event_handler_list
.first_handler
== NULL
)
1164 async_event_handler_list
.last_handler
= NULL
;
1168 prev_ptr
= async_event_handler_list
.first_handler
;
1169 while (prev_ptr
&& prev_ptr
->next_handler
!= *async_handler_ptr
)
1170 prev_ptr
= prev_ptr
->next_handler
;
1171 gdb_assert (prev_ptr
);
1172 prev_ptr
->next_handler
= (*async_handler_ptr
)->next_handler
;
1173 if (async_event_handler_list
.last_handler
== (*async_handler_ptr
))
1174 async_event_handler_list
.last_handler
= prev_ptr
;
1176 xfree (*async_handler_ptr
);
1177 *async_handler_ptr
= NULL
;
1180 /* Create a timer that will expire in MILLISECONDS from now. When the
1181 timer is ready, PROC will be executed. At creation, the timer is
1182 aded to the timers queue. This queue is kept sorted in order of
1183 increasing timers. Return a handle to the timer struct. */
1185 create_timer (int milliseconds
, timer_handler_func
* proc
,
1186 gdb_client_data client_data
)
1188 struct gdb_timer
*timer_ptr
, *timer_index
, *prev_timer
;
1189 struct timeval time_now
, delta
;
1191 /* Compute seconds. */
1192 delta
.tv_sec
= milliseconds
/ 1000;
1193 /* Compute microseconds. */
1194 delta
.tv_usec
= (milliseconds
% 1000) * 1000;
1196 gettimeofday (&time_now
, NULL
);
1198 timer_ptr
= (struct gdb_timer
*) xmalloc (sizeof (*timer_ptr
));
1199 timer_ptr
->when
.tv_sec
= time_now
.tv_sec
+ delta
.tv_sec
;
1200 timer_ptr
->when
.tv_usec
= time_now
.tv_usec
+ delta
.tv_usec
;
1202 if (timer_ptr
->when
.tv_usec
>= 1000000)
1204 timer_ptr
->when
.tv_sec
+= 1;
1205 timer_ptr
->when
.tv_usec
-= 1000000;
1207 timer_ptr
->proc
= proc
;
1208 timer_ptr
->client_data
= client_data
;
1209 timer_list
.num_timers
++;
1210 timer_ptr
->timer_id
= timer_list
.num_timers
;
1212 /* Now add the timer to the timer queue, making sure it is sorted in
1213 increasing order of expiration. */
1215 for (timer_index
= timer_list
.first_timer
;
1216 timer_index
!= NULL
;
1217 timer_index
= timer_index
->next
)
1219 /* If the seconds field is greater or if it is the same, but the
1220 microsecond field is greater. */
1221 if ((timer_index
->when
.tv_sec
> timer_ptr
->when
.tv_sec
)
1222 || ((timer_index
->when
.tv_sec
== timer_ptr
->when
.tv_sec
)
1223 && (timer_index
->when
.tv_usec
> timer_ptr
->when
.tv_usec
)))
1227 if (timer_index
== timer_list
.first_timer
)
1229 timer_ptr
->next
= timer_list
.first_timer
;
1230 timer_list
.first_timer
= timer_ptr
;
1235 for (prev_timer
= timer_list
.first_timer
;
1236 prev_timer
->next
!= timer_index
;
1237 prev_timer
= prev_timer
->next
)
1240 prev_timer
->next
= timer_ptr
;
1241 timer_ptr
->next
= timer_index
;
1244 gdb_notifier
.timeout_valid
= 0;
1245 return timer_ptr
->timer_id
;
1248 /* There is a chance that the creator of the timer wants to get rid of
1249 it before it expires. */
1251 delete_timer (int id
)
1253 struct gdb_timer
*timer_ptr
, *prev_timer
= NULL
;
1255 /* Find the entry for the given timer. */
1257 for (timer_ptr
= timer_list
.first_timer
; timer_ptr
!= NULL
;
1258 timer_ptr
= timer_ptr
->next
)
1260 if (timer_ptr
->timer_id
== id
)
1264 if (timer_ptr
== NULL
)
1266 /* Get rid of the timer in the timer list. */
1267 if (timer_ptr
== timer_list
.first_timer
)
1268 timer_list
.first_timer
= timer_ptr
->next
;
1271 for (prev_timer
= timer_list
.first_timer
;
1272 prev_timer
->next
!= timer_ptr
;
1273 prev_timer
= prev_timer
->next
)
1275 prev_timer
->next
= timer_ptr
->next
;
1279 gdb_notifier
.timeout_valid
= 0;
1282 /* When a timer event is put on the event queue, it will be handled by
1283 this function. Just call the associated procedure and delete the
1284 timer event from the event queue. Repeat this for each timer that
1287 handle_timer_event (event_data dummy
)
1289 struct timeval time_now
;
1290 struct gdb_timer
*timer_ptr
, *saved_timer
;
1292 gettimeofday (&time_now
, NULL
);
1293 timer_ptr
= timer_list
.first_timer
;
1295 while (timer_ptr
!= NULL
)
1297 if ((timer_ptr
->when
.tv_sec
> time_now
.tv_sec
)
1298 || ((timer_ptr
->when
.tv_sec
== time_now
.tv_sec
)
1299 && (timer_ptr
->when
.tv_usec
> time_now
.tv_usec
)))
1302 /* Get rid of the timer from the beginning of the list. */
1303 timer_list
.first_timer
= timer_ptr
->next
;
1304 saved_timer
= timer_ptr
;
1305 timer_ptr
= timer_ptr
->next
;
1306 /* Call the procedure associated with that timer. */
1307 (*saved_timer
->proc
) (saved_timer
->client_data
);
1308 xfree (saved_timer
);
1311 gdb_notifier
.timeout_valid
= 0;
1314 /* Check whether any timers in the timers queue are ready. If at least
1315 one timer is ready, stick an event onto the event queue. Even in
1316 case more than one timer is ready, one event is enough, because the
1317 handle_timer_event() will go through the timers list and call the
1318 procedures associated with all that have expired.l Update the
1319 timeout for the select() or poll() as well. */
1323 struct timeval time_now
, delta
;
1324 gdb_event
*event_ptr
;
1326 if (timer_list
.first_timer
!= NULL
)
1328 gettimeofday (&time_now
, NULL
);
1329 delta
.tv_sec
= timer_list
.first_timer
->when
.tv_sec
- time_now
.tv_sec
;
1330 delta
.tv_usec
= timer_list
.first_timer
->when
.tv_usec
- time_now
.tv_usec
;
1332 if (delta
.tv_usec
< 0)
1335 delta
.tv_usec
+= 1000000;
1338 /* Oops it expired already. Tell select / poll to return
1339 immediately. (Cannot simply test if delta.tv_sec is negative
1340 because time_t might be unsigned.) */
1341 if (timer_list
.first_timer
->when
.tv_sec
< time_now
.tv_sec
1342 || (timer_list
.first_timer
->when
.tv_sec
== time_now
.tv_sec
1343 && timer_list
.first_timer
->when
.tv_usec
< time_now
.tv_usec
))
1349 if (delta
.tv_sec
== 0 && delta
.tv_usec
== 0)
1351 event_ptr
= (gdb_event
*) xmalloc (sizeof (gdb_event
));
1352 event_ptr
->proc
= handle_timer_event
;
1353 event_ptr
->data
.integer
= timer_list
.first_timer
->timer_id
;
1354 async_queue_event (event_ptr
);
1357 /* Now we need to update the timeout for select/ poll, because
1358 we don't want to sit there while this timer is expiring. */
1362 gdb_notifier
.poll_timeout
= delta
.tv_sec
* 1000;
1364 internal_error (__FILE__
, __LINE__
,
1365 _("use_poll without HAVE_POLL"));
1366 #endif /* HAVE_POLL */
1370 gdb_notifier
.select_timeout
.tv_sec
= delta
.tv_sec
;
1371 gdb_notifier
.select_timeout
.tv_usec
= delta
.tv_usec
;
1373 gdb_notifier
.timeout_valid
= 1;
1376 gdb_notifier
.timeout_valid
= 0;